bitvavo-api-upgraded 2.2.0__tar.gz → 3.0.0__tar.gz

{bitvavo_api_upgraded-2.2.0 → bitvavo_api_upgraded-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bitvavo-api-upgraded
-Version: 2.2.0
+Version: 3.0.0
 Summary: A unit-tested fork of the Bitvavo API
 Author: Bitvavo BV (original code), NostraDavid
 Author-email: NostraDavid <55331731+NostraDavid@users.noreply.github.com>

{bitvavo_api_upgraded-2.2.0 → bitvavo_api_upgraded-3.0.0}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "uv_build"
 # https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html
 [project]
 name = "bitvavo-api-upgraded"
-version = "2.2.0"
+version = "3.0.0"
 description = "A unit-tested fork of the Bitvavo API"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -104,7 +104,7 @@ dev-dependencies = [
 ]
 
 [tool.bumpversion]
-current_version = "2.2.0"
+current_version = "3.0.0"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{bitvavo_api_upgraded-2.2.0 → bitvavo_api_upgraded-3.0.0}/src/bitvavo_api_upgraded/bitvavo.py

@@ -25,7 +25,7 @@ configure_loggers()
 logger = get_logger(__name__)
 
 
-def createSignature(timestamp: ms, method: str, url: str, body: anydict | None, api_secret: str) -> str:
+def create_signature(timestamp: ms, method: str, url: str, body: anydict | None, api_secret: str) -> str:
     string = f"{timestamp}{method}/v2{url}"
     if body is not None and len(body.keys()) > 0:
         string += json.dumps(body, separators=(",", ":"))
@@ -33,7 +33,7 @@ def createSignature(timestamp: ms, method: str, url: str, body: anydict | None,
     return signature
 
 
-def createPostfix(options: anydict | None) -> str:
+def create_postfix(options: anydict | None) -> str:
     """Generate a URL postfix, based on the `options` dict.
 
     ---
@@ -67,15 +67,15 @@ def _epoch_millis(dt: dt.datetime) -> int:
     return int(dt.timestamp() * 1000)
 
 
-def asksCompare(a: float, b: float) -> bool:
+def asks_compare(a: float, b: float) -> bool:
     return a < b
 
 
-def bidsCompare(a: float, b: float) -> bool:
+def bids_compare(a: float, b: float) -> bool:
     return a > b
 
 
-def sortAndInsert(
+def sort_and_insert(
     asks_or_bids: list[list[str]],
     update: list[list[str]],
     compareFunc: Callable[[float, float], bool],
@@ -101,7 +101,7 @@ def sortAndInsert(
     return asks_or_bids
 
 
-def processLocalBook(ws: Bitvavo.WebSocketAppFacade, message: anydict) -> None:
+def process_local_book(ws: Bitvavo.WebSocketAppFacade, message: anydict) -> None:
     market: str = ""
     if "action" in message:
         if message["action"] == "getBook":
@@ -115,10 +115,10 @@ def processLocalBook(ws: Bitvavo.WebSocketAppFacade, message: anydict) -> None:
 
         if message["nonce"] != ws.localBook[market]["nonce"] + 1:
             # I think I've fixed this, by looking at the other Bitvavo repos (search for 'nonce' or '!=' 😆)
-            ws.subscriptionBook(market, ws.callbacks[market])
+            ws.subscription_book(market, ws.callbacks[market])
             return
-        ws.localBook[market]["bids"] = sortAndInsert(ws.localBook[market]["bids"], message["bids"], bidsCompare)
-        ws.localBook[market]["asks"] = sortAndInsert(ws.localBook[market]["asks"], message["asks"], asksCompare)
+        ws.localBook[market]["bids"] = sort_and_insert(ws.localBook[market]["bids"], message["bids"], bids_compare)
+        ws.localBook[market]["asks"] = sort_and_insert(ws.localBook[market]["asks"], message["asks"], asks_compare)
         ws.localBook[market]["nonce"] = message["nonce"]
 
     if market != "":
@@ -423,7 +423,7 @@ class Bitvavo:
         )
         time.sleep(napTime + 1)  # +1 to add a tiny bit of buffer time
 
-    def calcLag(self) -> ms:
+    def calc_lag(self) -> ms:
         """
         Calculate the time difference between the client and server; use this value with BITVAVO_API_UPGRADED_LAG,
         when you make an api call, to precent 304 errors.
@@ -445,8 +445,8 @@ class Bitvavo:
 
         return ms(sum(lag_list) / len(lag_list))
 
-    def getRemainingLimit(self) -> int:
-        """Get the remaing rate limit
+    def get_remaining_limit(self) -> int:
+        """Get the remaining rate limit
 
         ---
         Returns:
@@ -456,7 +456,7 @@ class Bitvavo:
         """
         return self.rateLimitRemaining
 
-    def updateRateLimit(self, response: anydict | errordict) -> None:
+    def update_rate_limit(self, response: anydict | errordict) -> None:
         """
         Update the rate limited
 
@@ -488,7 +488,7 @@ class Bitvavo:
             logger.info("napping-until-ban-lifted")
             time.sleep(timeToWait + 1)  # plus one second to ENSURE we're able to run again.
 
-    def publicRequest(
+    def public_request(
         self,
         url: str,
         rateLimitingWeight: int = 1,
@@ -541,7 +541,7 @@ class Bitvavo:
 
         if api_key:
             now = time_ms() + bitvavo_upgraded_settings.LAG
-            sig = createSignature(now, "GET", url.replace(self.base, ""), None, api_secret)
+            sig = create_signature(now, "GET", url.replace(self.base, ""), None, api_secret)
             headers = {
                 "bitvavo-access-key": api_key,
                 "bitvavo-access-signature": sig,
@@ -559,11 +559,11 @@ class Bitvavo:
             self._update_rate_limit_for_key(key_index, dict(r.headers))
 
         # Also update legacy rate limit tracking
-        self.updateRateLimit(r.json() if "error" in r.json() else dict(r.headers))
+        self.update_rate_limit(r.json() if "error" in r.json() else dict(r.headers))
 
         return r.json()  # type:ignore[no-any-return]
 
-    def privateRequest(
+    def private_request(
         self,
         endpoint: str,
         postfix: str,
@@ -616,7 +616,7 @@ class Bitvavo:
         self._current_api_secret = api_secret
 
         now = time_ms() + bitvavo_upgraded_settings.LAG
-        sig = createSignature(now, method, (endpoint + postfix), body, api_secret)
+        sig = create_signature(now, method, (endpoint + postfix), body, api_secret)
         url = self.base + endpoint + postfix
         headers = {
             "bitvavo-access-key": api_key,
@@ -651,7 +651,7 @@ class Bitvavo:
             self._update_rate_limit_for_key(key_index, dict(r.headers))
 
         # Also update legacy rate limit tracking
-        self.updateRateLimit(r.json() if "error" in r.json() else dict(r.headers))
+        self.update_rate_limit(r.json() if "error" in r.json() else dict(r.headers))
 
         return r.json()
 
@@ -685,7 +685,7 @@ class Bitvavo:
         {"time": 1539180275424 }
         ```
         """
-        return self.publicRequest(f"{self.base}/time")  # type: ignore[return-value]
+        return self.public_request(f"{self.base}/time")  # type: ignore[return-value]
 
     def markets(
         self,
@@ -763,8 +763,8 @@ class Bitvavo:
         # The specific DataFrame type depends on the selected format.
         ```
         """
-        postfix = createPostfix(options)
-        result = self.publicRequest(f"{self.base}/markets{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/markets{postfix}")  # type: ignore[return-value]
         return convert_to_dataframe(result, output_format)
 
     def assets(
@@ -841,8 +841,8 @@ class Bitvavo:
         # The specific DataFrame type depends on the selected format.
         ```
         """
-        postfix = createPostfix(options)
-        result = self.publicRequest(f"{self.base}/assets{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/assets{postfix}")  # type: ignore[return-value]
         return convert_to_dataframe(result, output_format)
 
     def book(self, market: str, options: intdict | None = None) -> dict[str, str | int | list[str]] | errordict:
@@ -887,10 +887,10 @@ class Bitvavo:
         assert result == 714.48  # EUR can be gained from this bid if it's sold (minus the fee)
         ```
         """
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/{market}/book{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.public_request(f"{self.base}/{market}/book{postfix}")  # type: ignore[return-value]
 
-    def publicTrades(
+    def public_trades(
         self,
         market: str,
         options: strintdict | None = None,
@@ -963,8 +963,8 @@ class Bitvavo:
         # Returns the above data as a DataFrame in the requested format (pandas, polars, etc.)
         ```
         """
-        postfix = createPostfix(options)
-        result = self.publicRequest(f"{self.base}/{market}/trades{postfix}", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/{market}/trades{postfix}", 5)  # type: ignore[return-value]
         return convert_to_dataframe(result, output_format)
 
     def candles(
@@ -1053,11 +1053,11 @@ class Bitvavo:
             options["start"] = _epoch_millis(start)
         if end is not None:
             options["end"] = _epoch_millis(end)
-        postfix = createPostfix(options)
-        result = self.publicRequest(f"{self.base}/{market}/candles{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/{market}/candles{postfix}")  # type: ignore[return-value]
         return convert_candles_to_dataframe(result, output_format)
 
-    def tickerPrice(
+    def ticker_price(
         self,
         options: strdict | None = None,
         output_format: OutputFormat = OutputFormat.DICT,
@@ -1127,11 +1127,11 @@ class Bitvavo:
         # Returns a DataFrame with columns: market, price
         ```
         """
-        postfix = createPostfix(options)
-        result = self.publicRequest(f"{self.base}/ticker/price{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/ticker/price{postfix}")  # type: ignore[return-value]
         return convert_to_dataframe(result, output_format)
 
-    def tickerBook(
+    def ticker_book(
         self,
         options: strdict | None = None,
         output_format: OutputFormat = OutputFormat.DICT,
@@ -1194,8 +1194,8 @@ class Bitvavo:
         # Returns a DataFrame with columns: market, bid, ask, bidSize, askSize
         ```
         """
-        postfix = createPostfix(options)
-        result = self.publicRequest(f"{self.base}/ticker/book{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/ticker/book{postfix}")  # type: ignore[return-value]
         return convert_to_dataframe(result, output_format)
 
     def ticker24h(
@@ -1283,11 +1283,11 @@ class Bitvavo:
         rateLimitingWeight = 25
         if "market" in options:
             rateLimitingWeight = 1
-        postfix = createPostfix(options)
-        result = self.publicRequest(f"{self.base}/ticker/24h{postfix}", rateLimitingWeight)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/ticker/24h{postfix}", rateLimitingWeight)  # type: ignore[return-value]
         return convert_to_dataframe(result, output_format)
 
-    def reportTrades(
+    def report_trades(
         self,
         market: str,
         options: strintdict | None = None,
@@ -1350,11 +1350,11 @@ class Bitvavo:
         ]
         ```
         """
-        postfix = createPostfix(options)
-        result = self.publicRequest(f"{self.base}/report/{market}/trades{postfix}", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.public_request(f"{self.base}/report/{market}/trades{postfix}", 5)  # type: ignore[return-value]
         return convert_to_dataframe(result, output_format)
 
-    def reportBook(self, market: str, options: intdict | None = None) -> dict[str, str | int | list[str]] | errordict:
+    def report_book(self, market: str, options: intdict | None = None) -> dict[str, str | int | list[str]] | errordict:
         """Get MiCA-compliant order book report for a specific market
 
         Returns the list of all bids and asks for the specified market, sorted by price.
@@ -1391,10 +1391,10 @@ class Bitvavo:
         }
         ```
         """
-        postfix = createPostfix(options)
-        return self.publicRequest(f"{self.base}/report/{market}/book{postfix}")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.public_request(f"{self.base}/report/{market}/book{postfix}")  # type: ignore[return-value]
 
-    def placeOrder(self, market: str, side: str, orderType: str, operatorId: int, body: anydict) -> anydict:
+    def place_order(self, market: str, side: str, orderType: str, operatorId: int, body: anydict) -> anydict:
         """Place a new order on the exchange
 
         ---
@@ -1523,9 +1523,9 @@ class Bitvavo:
         body["side"] = side
         body["orderType"] = orderType
         body["operatorId"] = operatorId
-        return self.privateRequest("/order", "", body, "POST")  # type: ignore[return-value]
+        return self.private_request("/order", "", body, "POST")  # type: ignore[return-value]
 
-    def updateOrder(self, market: str, orderId: str, operatorId: int, body: anydict) -> anydict:
+    def update_order(self, market: str, orderId: str, operatorId: int, body: anydict) -> anydict:
         """Update an existing order for a specific market. Make sure that at least one of the optional parameters is set, otherwise nothing will be updated.
 
         ---
@@ -1609,9 +1609,9 @@ class Bitvavo:
         body["market"] = market
         body["orderId"] = orderId
         body["operatorId"] = operatorId
-        return self.privateRequest("/order", "", body, "PUT")  # type: ignore[return-value]
+        return self.private_request("/order", "", body, "PUT")  # type: ignore[return-value]
 
-    def cancelOrder(
+    def cancel_order(
         self,
         market: str,
         operatorId: int,
@@ -1657,10 +1657,10 @@ class Bitvavo:
         elif orderId is not None:
             params["orderId"] = orderId
 
-        postfix = createPostfix(params)
-        return self.privateRequest("/order", postfix, {}, "DELETE")  # type: ignore[return-value]
+        postfix = create_postfix(params)
+        return self.private_request("/order", postfix, {}, "DELETE")  # type: ignore[return-value]
 
-    def getOrder(self, market: str, orderId: str) -> list[anydict] | errordict:
+    def get_order(self, market: str, orderId: str) -> list[anydict] | errordict:
         """Get an existing order for a specific market
 
         ---
@@ -1722,10 +1722,10 @@ class Bitvavo:
         }
         ```
         """
-        postfix = createPostfix({"market": market, "orderId": orderId})
-        return self.privateRequest("/order", postfix, {}, "GET")  # type: ignore[return-value]
+        postfix = create_postfix({"market": market, "orderId": orderId})
+        return self.private_request("/order", postfix, {}, "GET")  # type: ignore[return-value]
 
-    def getOrders(self, market: str, options: anydict | None = None) -> list[anydict] | errordict:
+    def get_orders(self, market: str, options: anydict | None = None) -> list[anydict] | errordict:
         """Get multiple existing orders for a specific market
 
         ---
@@ -1798,10 +1798,10 @@ class Bitvavo:
         """  # noqa: E501
         options = _default(options, {})
         options["market"] = market
-        postfix = createPostfix(options)
-        return self.privateRequest("/orders", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/orders", postfix, {}, "GET", 5)  # type: ignore[return-value]
 
-    def cancelOrders(self, options: anydict | None = None) -> list[strdict] | errordict:
+    def cancel_orders(self, options: anydict | None = None) -> list[strdict] | errordict:
         """Cancel all existing orders for a specific market (or account)
 
         ---
@@ -1826,10 +1826,10 @@ class Bitvavo:
         ]
         ```
         """
-        postfix = createPostfix(options)
-        return self.privateRequest("/orders", postfix, {}, "DELETE")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/orders", postfix, {}, "DELETE")  # type: ignore[return-value]
 
-    def ordersOpen(self, options: anydict | None = None) -> list[anydict] | errordict:
+    def orders_open(self, options: anydict | None = None) -> list[anydict] | errordict:
         """Get all open orders, either for all markets, or a single market
 
         ---
@@ -1898,8 +1898,8 @@ class Bitvavo:
         rateLimitingWeight = 25
         if "market" in options:
             rateLimitingWeight = 1
-        postfix = createPostfix(options)
-        return self.privateRequest("/ordersOpen", postfix, {}, "GET", rateLimitingWeight)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/ordersOpen", postfix, {}, "GET", rateLimitingWeight)  # type: ignore[return-value]
 
     def trades(
         self,
@@ -1962,8 +1962,8 @@ class Bitvavo:
         """  # noqa: E501
         options = _default(options, {})
         options["market"] = market
-        postfix = createPostfix(options)
-        result = self.privateRequest("/trades", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.private_request("/trades", postfix, {}, "GET", 5)  # type: ignore[return-value]
         return convert_to_dataframe(result, output_format)
 
     def account(self) -> dict[str, strdict]:
@@ -1987,7 +1987,7 @@ class Bitvavo:
         }
         ```
         """
-        return self.privateRequest("/account", "", {}, "GET")  # type: ignore[return-value]
+        return self.private_request("/account", "", {}, "GET")  # type: ignore[return-value]
 
     def fees(self, market: str | None = None, quote: str | None = None) -> list[strdict] | errordict:
         """Get market fees for a specific market or quote currency
@@ -2024,8 +2024,8 @@ class Bitvavo:
             options["market"] = market
         if quote is not None:
             options["quote"] = quote
-        postfix = createPostfix(options)
-        return self.privateRequest("/account/fees", postfix, {}, "GET")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/account/fees", postfix, {}, "GET")  # type: ignore[return-value]
 
     def balance(
         self,
@@ -2081,11 +2081,11 @@ class Bitvavo:
         # with columns: symbol, available, inOrder
         ```
         """
-        postfix = createPostfix(options)
-        result = self.privateRequest("/balance", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.private_request("/balance", postfix, {}, "GET", 5)  # type: ignore[return-value]
         return convert_to_dataframe(result, output_format)
 
-    def accountHistory(self, options: strintdict | None = None) -> anydict | errordict:
+    def account_history(self, options: strintdict | None = None) -> anydict | errordict:
         """Get all past transactions for your account
 
         ---
@@ -2129,10 +2129,10 @@ class Bitvavo:
         }
         ```
         """
-        postfix = createPostfix(options)
-        return self.privateRequest("/account/history", postfix, {}, "GET")  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/account/history", postfix, {}, "GET")  # type: ignore[return-value]
 
-    def depositAssets(self, symbol: str) -> strdict:
+    def deposit_assets(self, symbol: str) -> strdict:
         """Get the deposit address (with paymentId for some assets) or bank account information to increase your balance
 
         ---
@@ -2164,10 +2164,10 @@ class Bitvavo:
         }
         ```
         """
-        postfix = createPostfix({"symbol": symbol})
-        return self.privateRequest("/deposit", postfix, {}, "GET")  # type: ignore[return-value]
+        postfix = create_postfix({"symbol": symbol})
+        return self.private_request("/deposit", postfix, {}, "GET")  # type: ignore[return-value]
 
-    def depositHistory(self, options: anydict | None = None) -> list[anydict] | errordict:
+    def deposit_history(self, options: anydict | None = None) -> list[anydict] | errordict:
         """Get the deposit history of the account
 
         Even when you want something from a single `symbol`, you'll still receive a list with multiple deposits.
@@ -2215,10 +2215,10 @@ class Bitvavo:
         ]
         ```
         """  # noqa: E501
-        postfix = createPostfix(options)
-        return self.privateRequest("/depositHistory", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        return self.private_request("/depositHistory", postfix, {}, "GET", 5)  # type: ignore[return-value]
 
-    def withdrawAssets(self, symbol: str, amount: str, address: str, body: anydict) -> anydict:
+    def withdraw_assets(self, symbol: str, amount: str, address: str, body: anydict) -> anydict:
         """Withdraw a coin/token to an external crypto address or bank account.
 
         ---
@@ -2253,9 +2253,9 @@ class Bitvavo:
         body["symbol"] = symbol
         body["amount"] = amount
         body["address"] = address
-        return self.privateRequest("/withdrawal", "", body, "POST")  # type: ignore[return-value]
+        return self.private_request("/withdrawal", "", body, "POST")  # type: ignore[return-value]
 
-    def withdrawalHistory(
+    def withdrawal_history(
         self,
         options: anydict | None = None,
         output_format: OutputFormat = OutputFormat.DICT,
@@ -2312,8 +2312,8 @@ class Bitvavo:
         ]
         ```
         """  # noqa: E501
-        postfix = createPostfix(options)
-        result = self.privateRequest("/withdrawalHistory", postfix, {}, "GET", 5)  # type: ignore[return-value]
+        postfix = create_postfix(options)
+        result = self.private_request("/withdrawalHistory", postfix, {}, "GET", 5)  # type: ignore[return-value]
         return convert_to_dataframe(result, output_format)
 
     # API Key Management Helper Methods
@@ -2428,7 +2428,7 @@ class Bitvavo:
             "rate_limit_reset_at": int(self.rateLimitResetAt),
         }
 
-    def newWebsocket(self) -> Bitvavo.WebSocketAppFacade:
+    def new_websocket(self) -> Bitvavo.WebSocketAppFacade:
         return Bitvavo.WebSocketAppFacade(self.APIKEY, self.APISECRET, self.ACCESSWINDOW, self.wsUrl, self)
 
     class WebSocketAppFacade:
@@ -2477,18 +2477,18 @@ class Bitvavo:
             self.keepBookCopy = False
             self.localBook: anydict = {}
 
-        def closeSocket(self) -> None:
+        def close_socket(self) -> None:
             self.ws.close()
             self.keepAlive = False
             self.receiveThread.join()
 
-        def waitForSocket(self, ws: WebSocketApp, message: str, private: bool) -> None:  # noqa: ARG002, FBT001
+        def wait_for_socket(self, ws: WebSocketApp, message: str, private: bool) -> None:  # noqa: ARG002, FBT001
             while self.keepAlive:
                 if (not private and self.open) or (private and self.authenticated and self.open):
                     return
                 time.sleep(0.1)
 
-        def doSend(self, ws: WebSocketApp, message: str, private: bool = False) -> None:  # noqa: FBT001, FBT002
+        def do_send(self, ws: WebSocketApp, message: str, private: bool = False) -> None:  # noqa: FBT001, FBT002
             # TODO(NostraDavid): add nap-time to the websocket, or do it here; I don't know yet.
             if private and self.APIKEY == "":
                 logger.error(
@@ -2496,7 +2496,7 @@ class Bitvavo:
                     tip="set the API key to be able to make private API calls",
                 )
                 return
-            self.waitForSocket(ws, message, private)
+            self.wait_for_socket(ws, message, private)
             ws.send(message)
             if self.bitvavo.debugging:
                 logger.debug("message-sent", message=message)
@@ -2509,7 +2509,7 @@ class Bitvavo:
 
             if "error" in msg_dict:
                 if msg_dict["errorCode"] == 105:  # noqa: PLR2004
-                    self.bitvavo.updateRateLimit(msg_dict)
+                    self.bitvavo.update_rate_limit(msg_dict)
                 if "error" in callbacks:
                     callbacks["error"](msg_dict)
                 else:
@@ -2609,47 +2609,47 @@ class Bitvavo:
             if self.bitvavo.debugging:
                 logger.debug("websocket-closed")
 
-        def checkReconnect(self) -> None:  # noqa: C901, PLR0912 (too-complex)
+        def check_reconnect(self) -> None:  # noqa: C901, PLR0912 (too-complex)
             if "subscriptionTicker" in self.callbacks:
                 for market in self.callbacks["subscriptionTicker"]:
-                    self.subscriptionTicker(market, self.callbacks["subscriptionTicker"][market])
+                    self.subscription_ticker(market, self.callbacks["subscriptionTicker"][market])
             if "subscriptionTicker24h" in self.callbacks:
                 for market in self.callbacks["subscriptionTicker24h"]:
-                    self.subscriptionTicker(market, self.callbacks["subscriptionTicker24h"][market])
+                    self.subscription_ticker(market, self.callbacks["subscriptionTicker24h"][market])
             if "subscriptionAccount" in self.callbacks:
                 for market in self.callbacks["subscriptionAccount"]:
-                    self.subscriptionAccount(market, self.callbacks["subscriptionAccount"][market])
+                    self.subscription_account(market, self.callbacks["subscriptionAccount"][market])
             if "subscriptionCandles" in self.callbacks:
                 for market in self.callbacks["subscriptionCandles"]:
                     for interval in self.callbacks["subscriptionCandles"][market]:
-                        self.subscriptionCandles(
+                        self.subscription_candles(
                             market,
                             interval,
                             self.callbacks["subscriptionCandles"][market][interval],
                         )
             if "subscriptionTrades" in self.callbacks:
                 for market in self.callbacks["subscriptionTrades"]:
-                    self.subscriptionTrades(market, self.callbacks["subscriptionTrades"][market])
+                    self.subscription_trades(market, self.callbacks["subscriptionTrades"][market])
             if "subscriptionBookUpdate" in self.callbacks:
                 for market in self.callbacks["subscriptionBookUpdate"]:
-                    self.subscriptionBookUpdate(market, self.callbacks["subscriptionBookUpdate"][market])
+                    self.subscription_book_update(market, self.callbacks["subscriptionBookUpdate"][market])
             if "subscriptionBookUser" in self.callbacks:
                 for market in self.callbacks["subscriptionBookUser"]:
-                    self.subscriptionBook(market, self.callbacks["subscriptionBookUser"][market])
+                    self.subscription_book(market, self.callbacks["subscriptionBookUser"][market])
 
         def on_open(self, ws: Any) -> None:  # noqa: ARG002
             now = time_ms() + bitvavo_upgraded_settings.LAG
             self.open = True
             self.reconnectTimer = 0.5
             if self.APIKEY != "":
-                self.doSend(
+                self.do_send(
                     self.ws,
                     json.dumps(
                         {
                             "window": str(self.ACCESSWINDOW),
                             "action": "authenticate",
                             "key": self.APIKEY,
-                            "signature": createSignature(now, "GET", "/websocket", {}, self.APISECRET),
+                            "signature": create_signature(now, "GET", "/websocket", {}, self.APISECRET),
                             "timestamp": now,
                         },
                     ),
@@ -2657,10 +2657,10 @@ class Bitvavo:
             if self.reconnect:
                 if self.bitvavo.debugging:
                     logger.debug("reconnecting")
-                thread = Thread(target=self.checkReconnect)
+                thread = Thread(target=self.check_reconnect)
                 thread.start()
 
-        def setErrorCallback(self, callback: Callable[[Any], None]) -> None:
+        def set_error_callback(self, callback: Callable[[Any], None]) -> None:
             self.callbacks["error"] = callback
 
         def time(self, callback: Callable[[Any], None]) -> None:
@@ -2688,7 +2688,7 @@ class Bitvavo:
             ```
             """
             self.callbacks["time"] = callback
-            self.doSend(self.ws, json.dumps({"action": "getTime"}))
+            self.do_send(self.ws, json.dumps({"action": "getTime"}))
 
         def markets(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get all available markets with some meta-information, unless options is given a `market` key.
@@ -2742,7 +2742,7 @@ class Bitvavo:
             """
             self.callbacks["markets"] = callback
             options["action"] = "getMarkets"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
         def assets(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get all available assets, unless `options` is given a `symbol` key.
@@ -2793,7 +2793,7 @@ class Bitvavo:
             """
             self.callbacks["assets"] = callback
             options["action"] = "getAssets"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
         def book(self, market: str, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get a book (with two lists: asks and bids, as they're called)
@@ -2840,7 +2840,7 @@ class Bitvavo:
             self.callbacks["book"] = callback
             options["market"] = market
             options["action"] = "getBook"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
         def publicTrades(self, market: str, options: anydict, callback: Callable[[Any], None]) -> None:
             """Publically available trades
@@ -2892,7 +2892,7 @@ class Bitvavo:
             self.callbacks["publicTrades"] = callback
             options["market"] = market
             options["action"] = "getTrades"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
         def candles(
             self,
@@ -2951,9 +2951,9 @@ class Bitvavo:
             options["market"] = market
             options["interval"] = interval
             options["action"] = "getCandles"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
-        def tickerPrice(self, options: anydict, callback: Callable[[Any], None]) -> None:
+        def ticker_price(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get the current price for each market
 
             ---
@@ -3001,9 +3001,9 @@ class Bitvavo:
             """
             self.callbacks["tickerPrice"] = callback
             options["action"] = "getTickerPrice"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
-        def tickerBook(self, options: anydict, callback: Callable[[Any], None]) -> None:
+        def ticker_book(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get current bid/ask, bidsize/asksize per market
 
             ---
@@ -3044,7 +3044,7 @@ class Bitvavo:
             """  # noqa: E501
             self.callbacks["tickerBook"] = callback
             options["action"] = "getTickerBook"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
         def ticker24h(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get current bid/ask, bidsize/asksize per market
@@ -3111,9 +3111,9 @@ class Bitvavo:
             """
             self.callbacks["ticker24h"] = callback
             options["action"] = "getTicker24h"
-            self.doSend(self.ws, json.dumps(options))
+            self.do_send(self.ws, json.dumps(options))
 
-        def placeOrder(
+        def place_order(
             self,
             market: str,
             side: str,
@@ -3253,9 +3253,9 @@ class Bitvavo:
             body["orderType"] = orderType
             body["operatorId"] = operatorId
             body["action"] = "privateCreateOrder"
-            self.doSend(self.ws, json.dumps(body), True)
+            self.do_send(self.ws, json.dumps(body), True)
 
-        def updateOrder(
+        def update_order(
             self,
             market: str,
             orderId: str,
@@ -3351,9 +3351,9 @@ class Bitvavo:
             body["orderId"] = orderId
             body["operatorId"] = operatorId
             body["action"] = "privateUpdateOrder"
-            self.doSend(self.ws, json.dumps(body), True)
+            self.do_send(self.ws, json.dumps(body), True)
 
-        def cancelOrder(
+        def cancel_order(
             self,
             market: str,
             operatorId: int,
@@ -3403,9 +3403,9 @@ class Bitvavo:
             elif orderId is not None:
                 options["orderId"] = orderId
 
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
-        def getOrder(self, market: str, orderId: str, callback: Callable[[Any], None]) -> None:
+        def get_order(self, market: str, orderId: str, callback: Callable[[Any], None]) -> None:
             """Get an existing order for a specific market
 
             ---
@@ -3474,9 +3474,9 @@ class Bitvavo:
                 "market": market,
                 "orderId": orderId,
             }
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
-        def getOrders(self, market: str, options: anydict, callback: Callable[[Any], None]) -> None:
+        def get_orders(self, market: str, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get multiple existing orders for a specific market
 
             ---
@@ -3554,9 +3554,9 @@ class Bitvavo:
             self.callbacks["getOrders"] = callback
             options["action"] = "privateGetOrders"
             options["market"] = market
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
-        def cancelOrders(self, options: anydict, callback: Callable[[Any], None]) -> None:
+        def cancel_orders(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Cancel all existing orders for a specific market (or account)
 
             ---
@@ -3584,9 +3584,9 @@ class Bitvavo:
             """
             self.callbacks["cancelOrders"] = callback
             options["action"] = "privateCancelOrders"
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
-        def ordersOpen(self, options: anydict, callback: Callable[[Any], None]) -> None:
+        def orders_open(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get all open orders, either for all markets, or a single market
 
             ---
@@ -3654,7 +3654,7 @@ class Bitvavo:
             """
             self.callbacks["ordersOpen"] = callback
             options["action"] = "privateGetOrdersOpen"
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
         def trades(self, market: str, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get all historic trades from this account
@@ -3703,7 +3703,7 @@ class Bitvavo:
             self.callbacks["trades"] = callback
             options["action"] = "privateGetTrades"
             options["market"] = market
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
         def account(self, callback: Callable[[Any], None]) -> None:
             """Get all fees for this account
@@ -3733,7 +3733,7 @@ class Bitvavo:
             ```
             """
             self.callbacks["account"] = callback
-            self.doSend(self.ws, json.dumps({"action": "privateGetAccount"}), True)
+            self.do_send(self.ws, json.dumps({"action": "privateGetAccount"}), True)
 
         def balance(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get the balance for this account
@@ -3766,9 +3766,9 @@ class Bitvavo:
             """
             options["action"] = "privateGetBalance"
             self.callbacks["balance"] = callback
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
-        def depositAssets(self, symbol: str, callback: Callable[[Any], None]) -> None:
+        def deposit_assets(self, symbol: str, callback: Callable[[Any], None]) -> None:
             """
             Get the deposit address (with paymentId for some assets) or bank account information to increase your
             balance.
@@ -3804,13 +3804,13 @@ class Bitvavo:
             ```
             """
             self.callbacks["depositAssets"] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps({"action": "privateDepositAssets", "symbol": symbol}),
                 True,
             )
 
-        def depositHistory(self, options: anydict, callback: Callable[[Any], None]) -> None:
+        def deposit_history(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get the deposit history of the account
 
             Even when you want something from a single `symbol`, you'll still receive a list with multiple deposits.
@@ -3862,9 +3862,9 @@ class Bitvavo:
             """
             self.callbacks["depositHistory"] = callback
             options["action"] = "privateGetDepositHistory"
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
-        def withdrawAssets(
+        def withdraw_assets(
             self,
             symbol: str,
             amount: str,
@@ -3915,9 +3915,9 @@ class Bitvavo:
             body["symbol"] = symbol
             body["amount"] = amount
             body["address"] = address
-            self.doSend(self.ws, json.dumps(body), True)
+            self.do_send(self.ws, json.dumps(body), True)
 
-        def withdrawalHistory(self, options: anydict, callback: Callable[[Any], None]) -> None:
+        def withdrawal_history(self, options: anydict, callback: Callable[[Any], None]) -> None:
             """Get the withdrawal history
 
             ---
@@ -3958,9 +3958,9 @@ class Bitvavo:
             """
             self.callbacks["withdrawalHistory"] = callback
             options["action"] = "privateGetWithdrawalHistory"
-            self.doSend(self.ws, json.dumps(options), True)
+            self.do_send(self.ws, json.dumps(options), True)
 
-        def subscriptionTicker(self, market: str, callback: Callable[[Any], None]) -> None:
+        def subscription_ticker(self, market: str, callback: Callable[[Any], None]) -> None:
             # TODO(NostraDavid): one possible improvement here is to turn `market` into a list of markets, so we can sub
             # to all of them at once. Same goes for other `subscription*()`
             """
@@ -4002,7 +4002,7 @@ class Bitvavo:
             if "subscriptionTicker" not in self.callbacks:
                 self.callbacks["subscriptionTicker"] = {}
             self.callbacks["subscriptionTicker"][market] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -4012,7 +4012,7 @@ class Bitvavo:
                 ),
             )
 
-        def subscriptionTicker24h(self, market: str, callback: Callable[[Any], None]) -> None:
+        def subscription_ticker24h(self, market: str, callback: Callable[[Any], None]) -> None:
             """
             Subscribe to the ticker-24-hour channel, which means `callback` gets passed the new object every second, if
             values have changed.
@@ -4059,7 +4059,7 @@ class Bitvavo:
             if "subscriptionTicker24h" not in self.callbacks:
                 self.callbacks["subscriptionTicker24h"] = {}
             self.callbacks["subscriptionTicker24h"][market] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -4069,7 +4069,7 @@ class Bitvavo:
                 ),
             )
 
-        def subscriptionAccount(self, market: str, callback: Callable[[Any], None]) -> None:
+        def subscription_account(self, market: str, callback: Callable[[Any], None]) -> None:
             """
             Subscribes to the account channel, which sends an update whenever an event happens which is related to
             the account. These are 'order' events (create, update, cancel) or 'fill' events (a trade occurred).
@@ -4136,7 +4136,7 @@ class Bitvavo:
             if "subscriptionAccount" not in self.callbacks:
                 self.callbacks["subscriptionAccount"] = {}
             self.callbacks["subscriptionAccount"][market] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -4147,7 +4147,7 @@ class Bitvavo:
                 True,
             )
 
-        def subscriptionCandles(self, market: str, interval: str, callback: Callable[[Any], None]) -> None:
+        def subscription_candles(self, market: str, interval: str, callback: Callable[[Any], None]) -> None:
             """Subscribes to candles and returns a candle each time a new one is formed, depending on the interval
 
             ---
@@ -4195,7 +4195,7 @@ class Bitvavo:
             if market not in self.callbacks["subscriptionCandles"]:
                 self.callbacks["subscriptionCandles"][market] = {}
             self.callbacks["subscriptionCandles"][market][interval] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -4211,7 +4211,7 @@ class Bitvavo:
                 ),
             )
 
-        def subscriptionTrades(self, market: str, callback: Callable[[Any], None]) -> None:
+        def subscription_trades(self, market: str, callback: Callable[[Any], None]) -> None:
             """Subscribes to trades, which sends an object whenever a trade has occurred.
 
             ---
@@ -4248,7 +4248,7 @@ class Bitvavo:
             if "subscriptionTrades" not in self.callbacks:
                 self.callbacks["subscriptionTrades"] = {}
             self.callbacks["subscriptionTrades"][market] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -4258,7 +4258,7 @@ class Bitvavo:
                 ),
             )
 
-        def subscriptionBookUpdate(self, market: str, callback: Callable[[Any], None]) -> None:
+        def subscription_book_update(self, market: str, callback: Callable[[Any], None]) -> None:
             """Subscribes to the book and returns a delta on every change to the book.
 
             ---
@@ -4315,7 +4315,7 @@ class Bitvavo:
             if "subscriptionBookUpdate" not in self.callbacks:
                 self.callbacks["subscriptionBookUpdate"] = {}
             self.callbacks["subscriptionBookUpdate"][market] = callback
-            self.doSend(
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -4325,7 +4325,7 @@ class Bitvavo:
                 ),
             )
 
-        def subscriptionBook(self, market: str, callback: Callable[[Any], None]) -> None:
+        def subscription_book(self, market: str, callback: Callable[[Any], None]) -> None:
             """Subscribes to the book and returns a delta on every change to the book.
 
             ---
@@ -4385,8 +4385,8 @@ class Bitvavo:
             self.callbacks["subscriptionBookUser"][market] = callback
             if "subscriptionBook" not in self.callbacks:
                 self.callbacks["subscriptionBook"] = {}
-            self.callbacks["subscriptionBook"][market] = processLocalBook
-            self.doSend(
+            self.callbacks["subscriptionBook"][market] = process_local_book
+            self.do_send(
                 self.ws,
                 json.dumps(
                     {
@@ -4397,4 +4397,4 @@ class Bitvavo:
             )
 
             self.localBook[market] = {}
-            self.doSend(self.ws, json.dumps({"action": "getBook", "market": market}))
+            self.do_send(self.ws, json.dumps({"action": "getBook", "market": market}))