bitvavo-api-upgraded 1.16.0__py3-none-any.whl → 1.17.0__py3-none-any.whl

bitvavo_api_upgraded/__init__.py

@@ -0,0 +1,3 @@
+from bitvavo_api_upgraded.bitvavo import Bitvavo
+
+__all__ = ["Bitvavo"]

bitvavo_api_upgraded/bitvavo.py

@@ -15,22 +15,22 @@ from websocket import WebSocketApp  # missing stubs for WebSocketApp
 
 from bitvavo_api_upgraded.helper_funcs import configure_loggers, time_ms, time_to_wait
 from bitvavo_api_upgraded.settings import BITVAVO_API_UPGRADED
-from bitvavo_api_upgraded.type_aliases import anydict, errordict, intdict, ms, s_f, strdict
+from bitvavo_api_upgraded.type_aliases import anydict, errordict, intdict, ms, s_f, strdict, strintdict
 
 configure_loggers()
 
 logger = get_logger(__name__)
 
 
-def createSignature(timestamp: ms, method: str, url: str, body: anydict, api_secret: str) -> str:
+def createSignature(timestamp: ms, method: str, url: str, body: anydict | None, api_secret: str) -> str:
     string = f"{timestamp}{method}/v2{url}"
-    if len(body.keys()) != 0:
+    if body is not None and len(body.keys()) > 0:
         string += json.dumps(body, separators=(",", ":"))
     signature = hmac.new(api_secret.encode("utf-8"), string.encode("utf-8"), hashlib.sha256).hexdigest()
     return signature
 
 
-def createPostfix(options: anydict) -> str:
+def createPostfix(options: anydict | None) -> str:
     """Generate a URL postfix, based on the `options` dict.
 
     ---
@@ -41,11 +41,29 @@ def createPostfix(options: anydict) -> str:
     Returns:
         str: [description]
     """
+    options = _default(options, {})
     params = [f"{key}={options[key]}" for key in options]
     postfix = "&".join(params)  # intersperse
     return f"?{postfix}" if len(options) > 0 else postfix
 
 
+def _default(value: anydict | None, fallback: anydict) -> anydict:
+    """
+    Note that is close, but not actually equal to:
+
+    `return value or fallback`
+
+    I checked this with a temporary hypothesis test.
+
+    This note is all you will get out of me.
+    """
+    return value if value is not None else fallback
+
+
+def _epoch_millis(dt: dt.datetime) -> int:
+    return int(dt.timestamp() * 1000)
+
+
 def asksCompare(a: float, b: float) -> bool:
     return a < b
 
@@ -105,12 +123,15 @@ def processLocalBook(ws: Bitvavo.WebSocketAppFacade, message: anydict) -> None:
 
 
 class ReceiveThread(Thread):
+    """This used to be `class rateLimitThread`."""
+
     def __init__(self, ws: WebSocketApp, ws_facade: Bitvavo.WebSocketAppFacade) -> None:
         self.ws = ws
         self.ws_facade = ws_facade
         Thread.__init__(self)
 
     def run(self) -> None:
+        """This used to be `self.waitForReset`."""
         try:
             while self.ws_facade.keepAlive:
                 self.ws.run_forever()
@@ -283,10 +304,10 @@ class Bitvavo:
             )
             logger.info("napping-until-ban-lifted")
             time.sleep(timeToWait + 1)  # plus one second to ENSURE we're able to run again.
-        if "Bitvavo-Ratelimit-Remaining" in response:
-            self.rateLimitRemaining = int(response["Bitvavo-Ratelimit-Remaining"])
-        if "Bitvavo-Ratelimit-ResetAt" in response:
-            self.rateLimitResetAt = int(response["Bitvavo-Ratelimit-ResetAt"])
+        if "bitvavo-ratelimit-remaining" in response:
+            self.rateLimitRemaining = int(response["bitvavo-ratelimit-remaining"])
+        if "bitvavo-ratelimit-resetat" in response:
+            self.rateLimitResetAt = int(response["bitvavo-ratelimit-resetat"])
 
     def publicRequest(
         self,
@@ -324,12 +345,12 @@ class Bitvavo:
             )
         if self.APIKEY != "":
             now = time_ms() + BITVAVO_API_UPGRADED.LAG
-            sig = createSignature(now, "GET", url.replace(self.base, ""), {}, self.APISECRET)
+            sig = createSignature(now, "GET", url.replace(self.base, ""), None, self.APISECRET)
             headers = {
-                "Bitvavo-Access-Key": self.APIKEY,
-                "Bitvavo-Access-Signature": sig,
-                "Bitvavo-Access-Timestamp": str(now),
-                "Bitvavo-Access-Window": str(self.ACCESSWINDOW),
+                "bitvavo-access-key": self.APIKEY,
+                "bitvavo-access-signature": sig,
+                "bitvavo-access-timestamp": str(now),
+                "bitvavo-access-window": str(self.ACCESSWINDOW),
             }
             r = get(url, headers=headers, timeout=(self.ACCESSWINDOW / 1000))
         else:
@@ -344,7 +365,7 @@ class Bitvavo:
         self,
         endpoint: str,
         postfix: str,
-        body: anydict,
+        body: anydict | None = None,
         method: str = "GET",
         rateLimitingWeight: int = 1,
     ) -> list[anydict] | list[list[str]] | intdict | strdict | anydict | Any | errordict:
@@ -377,10 +398,10 @@ class Bitvavo:
         sig = createSignature(now, method, (endpoint + postfix), body, self.APISECRET)
         url = self.base + endpoint + postfix
         headers = {
-            "Bitvavo-Access-Key": self.APIKEY,
-            "Bitvavo-Access-Signature": sig,
-            "Bitvavo-Access-Timestamp": str(now),
-            "Bitvavo-Access-Window": str(self.ACCESSWINDOW),
+            "bitvavo-access-key": self.APIKEY,
+            "bitvavo-access-signature": sig,
+            "bitvavo-access-timestamp": str(now),
+            "bitvavo-access-window": str(self.ACCESSWINDOW),
         }
         if self.debugging:
             logger.debug(
@@ -438,7 +459,7 @@ class Bitvavo:
         """
         return self.publicRequest(f"{self.base}/time")  # type: ignore[return-value]
 
-    def markets(self, options: strdict) -> list[anydict] | anydict | errordict:
+    def markets(self, options: strdict | None = None) -> list[anydict] | anydict | errordict:
         """Get all available markets with some meta-information, unless options is given a `market` key.
         Then you will get a single market, instead of a list of markets.
 
@@ -490,7 +511,7 @@ class Bitvavo:
         postfix = createPostfix(options)
         return self.publicRequest(f"{self.base}/markets{postfix}")  # type: ignore[return-value]
 
-    def assets(self, options: strdict) -> list[anydict] | anydict:
+    def assets(self, options: strdict | None = None) -> list[anydict] | anydict:
         """Get all available assets, unless `options` is given a `symbol` key.
         Then you will get a single asset, instead of a list of assets.
 
@@ -539,7 +560,7 @@ class Bitvavo:
         postfix = createPostfix(options)
         return self.publicRequest(f"{self.base}/assets{postfix}")  # type: ignore[return-value]
 
-    def book(self, market: str, options: intdict) -> dict[str, str | int | list[str]] | errordict:
+    def book(self, market: str, options: intdict | None = None) -> dict[str, str | int | list[str]] | errordict:
         """Get a book (with two lists: asks and bids, as they're called)
 
         ---
@@ -583,7 +604,7 @@ class Bitvavo:
         postfix = createPostfix(options)
         return self.publicRequest(f"{self.base}/{market}/book{postfix}")  # type: ignore[return-value]
 
-    def publicTrades(self, market: str, options: dict[str, str | int]) -> list[anydict] | errordict:
+    def publicTrades(self, market: str, options: strintdict | None = None) -> list[anydict] | errordict:
         """Publically available trades
 
         ---
@@ -633,11 +654,14 @@ class Bitvavo:
         postfix = createPostfix(options)
         return self.publicRequest(f"{self.base}/{market}/trades{postfix}", 5)  # type: ignore[return-value]
 
-    def candles(
+    def candles(  # noqa: PLR0913
         self,
         market: str,
         interval: str,
-        options: dict[str, str | int],
+        options: strintdict | None = None,
+        limit: int | None = None,
+        start: dt.datetime | None = None,
+        end: dt.datetime | None = None,
     ) -> list[list[str]] | errordict:
         """Get up to 1440 candles for a market, with a specific interval (candle size)
 
@@ -684,11 +708,18 @@ class Bitvavo:
         ]
         ```
         """
+        options = _default(options, {})
         options["interval"] = interval
+        if limit is not None:
+            options["limit"] = limit
+        if start is not None:
+            options["start"] = _epoch_millis(start)
+        if end is not None:
+            options["end"] = _epoch_millis(end)
         postfix = createPostfix(options)
         return self.publicRequest(f"{self.base}/{market}/candles{postfix}")  # type: ignore[return-value]
 
-    def tickerPrice(self, options: strdict) -> list[strdict] | strdict:
+    def tickerPrice(self, options: strdict | None = None) -> list[strdict] | strdict:
         """Get the current price for each market
 
         ---
@@ -736,7 +767,7 @@ class Bitvavo:
         postfix = createPostfix(options)
         return self.publicRequest(f"{self.base}/ticker/price{postfix}")  # type: ignore[return-value]
 
-    def tickerBook(self, options: strdict) -> list[strdict] | strdict:
+    def tickerBook(self, options: strdict | None = None) -> list[strdict] | strdict:
         """Get current bid/ask, bidsize/asksize per market
 
         ---
@@ -777,7 +808,7 @@ class Bitvavo:
         postfix = createPostfix(options)
         return self.publicRequest(f"{self.base}/ticker/book{postfix}")  # type: ignore[return-value]
 
-    def ticker24h(self, options: strdict) -> list[anydict] | anydict | errordict:
+    def ticker24h(self, options: strdict | None = None) -> list[anydict] | anydict | errordict:
         """Get current bid/ask, bidsize/asksize per market
 
         ---
@@ -839,6 +870,7 @@ class Bitvavo:
         ]
         ```
         """
+        options = _default(options, {})
         rateLimitingWeight = 25
         if "market" in options:
             rateLimitingWeight = 1
@@ -1143,7 +1175,7 @@ class Bitvavo:
         postfix = createPostfix({"market": market, "orderId": orderId})
         return self.privateRequest("/order", postfix, {}, "GET")  # type: ignore[return-value]
 
-    def getOrders(self, market: str, options: anydict) -> list[anydict] | errordict:
+    def getOrders(self, market: str, options: anydict | None = None) -> list[anydict] | errordict:
         """Get multiple existing orders for a specific market
 
         ---
@@ -1214,11 +1246,12 @@ class Bitvavo:
         ]
         ```
         """  # noqa: E501
+        options = _default(options, {})
         options["market"] = market
         postfix = createPostfix(options)
         return self.privateRequest("/orders", postfix, {}, "GET", 5)  # type: ignore[return-value]
 
-    def cancelOrders(self, options: anydict) -> list[strdict] | errordict:
+    def cancelOrders(self, options: anydict | None = None) -> list[strdict] | errordict:
         """Cancel all existing orders for a specific market (or account)
 
         ---
@@ -1246,7 +1279,7 @@ class Bitvavo:
         postfix = createPostfix(options)
         return self.privateRequest("/orders", postfix, {}, "DELETE")  # type: ignore[return-value]
 
-    def ordersOpen(self, options: anydict) -> list[anydict] | errordict:
+    def ordersOpen(self, options: anydict | None = None) -> list[anydict] | errordict:
         """Get all open orders, either for all markets, or a single market
 
         ---
@@ -1311,13 +1344,14 @@ class Bitvavo:
         ]
         ```
         """
+        options = _default(options, {})
         rateLimitingWeight = 25
         if "market" in options:
             rateLimitingWeight = 1
         postfix = createPostfix(options)
         return self.privateRequest("/ordersOpen", postfix, {}, "GET", rateLimitingWeight)  # type: ignore[return-value]
 
-    def trades(self, market: str, options: anydict) -> list[anydict] | errordict:
+    def trades(self, market: str, options: anydict | None = None) -> list[anydict] | errordict:
         """Get all historic trades from this account
 
         ---
@@ -1359,6 +1393,7 @@ class Bitvavo:
         ]
         ```
         """  # noqa: E501
+        options = _default(options, {})
         options["market"] = market
         postfix = createPostfix(options)
         return self.privateRequest("/trades", postfix, {}, "GET", 5)  # type: ignore[return-value]
@@ -1386,7 +1421,16 @@ class Bitvavo:
         """
         return self.privateRequest("/account", "", {}, "GET")  # type: ignore[return-value]
 
-    def balance(self, options: strdict) -> list[strdict] | errordict:
+    def fees(self, market: str | None = None, quote: str | None = None) -> list[strdict] | errordict:
+        options = {}
+        if market is not None:
+            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]
+
+    def balance(self, options: strdict | None = None) -> list[strdict] | errordict:
         """Get the balance for this account
 
         ---
@@ -1452,7 +1496,7 @@ class Bitvavo:
         postfix = createPostfix({"symbol": symbol})
         return self.privateRequest("/deposit", postfix, {}, "GET")  # type: ignore[return-value]
 
-    def depositHistory(self, options: anydict) -> list[anydict] | errordict:
+    def depositHistory(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.
@@ -1540,7 +1584,7 @@ class Bitvavo:
         body["address"] = address
         return self.privateRequest("/withdrawal", "", body, "POST")  # type: ignore[return-value]
 
-    def withdrawalHistory(self, options: anydict) -> list[anydict] | errordict:
+    def withdrawalHistory(self, options: anydict | None = None) -> list[anydict] | errordict:
         """Get the withdrawal history
 
         ---
@@ -1700,6 +1744,8 @@ class Bitvavo:
                     callbacks["trades"](msg_dict["response"])
                 elif msg_dict["action"] == "privateGetAccount":
                     callbacks["account"](msg_dict["response"])
+                elif msg_dict["action"] == "privateGetFees":
+                    callbacks["fees"](msg_dict["response"])
                 elif msg_dict["action"] == "privateGetBalance":
                     callbacks["balance"](msg_dict["response"])
                 elif msg_dict["action"] == "privateDepositAssets":

bitvavo_api_upgraded/helper_funcs.py

@@ -34,7 +34,7 @@ def configure_loggers() -> None:
     source: https://docs.python.org/3.9/library/logging.config.html#dictionary-schema-details
     """
     shared_pre_chain: list[Callable[[WrappedLogger, str, EventDict], EventDict]] = [
-        structlog.threadlocal.merge_threadlocal,
+        # structlog.threadlocal.merge_threadlocal,
         structlog.stdlib.add_logger_name,  # show which named logger made the message!
         structlog.processors.add_log_level,  # info, warning, error, etc
         structlog.processors.TimeStamper(fmt="%Y-%m-%dT%H:%M:%S", utc=False),  # add an ISO formatted string

bitvavo_api_upgraded/type_aliases.py

@@ -3,12 +3,14 @@ This file contains all type aliases that I use within the lib,
 to clearify the intention or semantics/meaning/unit of a variable
 """
 
-from typing import Any
+from typing import Any, Union
 
 # type simplification
 anydict = dict[str, Any]
 strdict = dict[str, str]
 intdict = dict[str, int]
+# can't use | here, with __future__. Not sure why.
+strintdict = dict[str, Union[str, int]]
 errordict = dict[str, Any]  # same type as anydict, but the semantics/meaning is different
 
 # note: You can also use these for type conversion, so instead of int(some_float / 1000), you can just do ms(some_float

bitvavo_api_upgraded-1.17.0.dist-info/METADATA

@@ -0,0 +1,319 @@
+Metadata-Version: 2.3
+Name: bitvavo-api-upgraded
+Version: 1.17.0
+Summary: A unit-tested fork of the Bitvavo API
+Project-URL: homepage, https://github.com/Thaumatorium/bitvavo-api-upgraded
+Project-URL: repository, https://github.com/Thaumatorium/bitvavo-api-upgraded
+Project-URL: changelog, https://github.com/Thaumatorium/bitvavo-api-upgraded/blob/master/CHANGELOG.md
+Author: Bitvavo BV (original code)
+Author-email: NostraDavid <55331731+NostraDavid@users.noreply.github.com>
+Maintainer-email: NostraDavid <55331731+NostraDavid@users.noreply.github.com>
+License: ISC License
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Framework :: Pytest
+Classifier: Framework :: tox
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: ISC License (ISCL)
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: python-decouple==3.*,>=3.5
+Requires-Dist: requests==2.*,>=2.26
+Requires-Dist: structlog==24.*,>=21.5
+Requires-Dist: websocket-client==1.*,>=1.2
+Description-Content-Type: text/markdown
+
+# Bitvavo API (upgraded)
+
+## Userguide
+
+`pip install bitvavo_api_upgraded`
+
+Works the same as the official API lib, but I have:
+
+- typing for _all_ functions and classes
+- unit tests (I already found three bugs that I fixed, because the original code
+  wasn't tested, at all)
+- a changelog, so you can track of the changes that I make
+- compatible with Python 3.7 and newer ([3.6 isn't supported as of
+  2021-12-23](https://endoflife.date/python))
+
+## Devguide
+
+```shell
+echo "install development requirements"
+uv sync
+echo "run tox, a program that creates separate environments for different python versions, for testing purposes (among other things)"
+uv run tox
+```
+
+### Semantic Versioning (SemVer)
+
+I'm using semantic versioning, which means that changes mean this:
+
+1. MAJOR version when you make incompatible API changes,
+1. MINOR version when you add functionality in a backwards compatible manner,
+   and
+1. PATCH version when you make backwards compatible bug fixes.
+
+### Versioning
+
+Copy the following block to CHANGELOG.md and add all information since last
+version bump
+
+```markdown
+## $UNRELEASED
+
+### Added
+
+...
+
+### Changed
+
+...
+
+### Removed
+
+...
+```
+
+Commit those changes.
+
+After that, run `bump-my-version bump (major|minor|patch)` to automatically
+replace `$UNRELEASED` with the new version number, and also automatically tag
+and commit (with tag) to release a new version via the Github workflow.
+
+## py.typed
+
+Perhaps a curious file, but it simply exists to let `mypy` know that the code is
+typed: [Don't forget `py.typed` for your typed Python package
+](https://blog.whtsky.me/tech/2021/dont-forget-py.typed-for-your-typed-python-package/)
+
+## Last note
+
+_below this line is the old README.md_
+
+---
+
+# Bitvavo SDK for Python
+
+Crypto starts with Bitvavo. You use Bitvavo SDK for Python to buy, sell, and
+store over 200 digital assets on Bitvavo from inside your app.
+
+To trade and execute your advanced trading strategies, Bitvavo SDK for Python is
+a wrapper that enables you to easily call every endpoint in [Bitvavo
+API](https://docs.bitvavo.com/).
+
+- [Prerequisites](#prerequisites) - what you need to start developing with
+  Bitvavo SDK for Python
+- [Get started](#get-started) - rapidly create an app and start trading with
+  Bitvavo
+- [About the SDK](#about-the-sdk) - general information about Bitvavo SDK for
+  Python
+- [API reference](https://docs.bitvavo.com/) - information on the specifics of
+  every parameter
+
+This page shows you how to use Bitvavo SDK for Python with WebSockets. For REST,
+see the [REST readme](docs/rest.md).
+
+## Prerequisites
+
+To start programming with Bitvavo SDK for Python you need:
+
+- [Python3](https://www.python.org/downloads/) installed on your development
+  environment
+
+  If you are working on macOS, ensure that you have installed SSH certificates:
+
+  ```terminal
+  open /Applications/Python\ 3.12/Install\ Certificates.command
+  open /Applications/Python\ 3.12/Update\ Shell\ Profile.command
+  ```
+
+- A Python app. Use your favorite IDE, or run from the command line
+- An [API key and
+  secret](https://support.bitvavo.com/hc/en-us/articles/4405059841809)
+  associated with your Bitvavo account
+
+  You control the actions your app can do using the rights you assign to the API
+  key. Possible rights are:
+
+  - **View**: retrieve information about your balance, account, deposit and
+    withdrawals
+  - **Trade**: place, update, view and cancel orders
+  - **Withdraw**: withdraw funds
+
+    Best practice is to not grant this privilege, withdrawals using the API do
+    not require 2FA and e-mail confirmation.
+
+## Get started
+
+Want to quickly make a trading app? Here you go:
+
+1. **Install Bitvavo SDK for Python**
+
+    In your Python app, add [Bitvavo SDK for
+    Python](https://github.com/bitvavo/python-bitvavo-api) from
+    [pypi.org](https://pypi.org/project/python-bitvavo-api/):
+
+    ```shell
+    python -m pip install python_bitvavo_api
+    ```
+
+    If you installed from `test.pypi.com`, update the requests library: `pip
+    install --upgrade  requests`.
+
+1. **Create a simple Bitvavo implementation**
+
+    Add the following code to a new file in your app:
+
+    ```python
+    from python_bitvavo_api.bitvavo import Bitvavo
+    import json
+    import time
+
+    # Use this class to connect to Bitvavo and make your first calls.
+    # Add trading strategies to implement your business logic.
+    class BitvavoImplementation:
+        api_key = "<Replace with your your API key from Bitvavo Dashboard>"
+        api_secret = "<Replace with your API secret from Bitvavo Dashboard>"
+        bitvavo_engine = None
+        bitvavo_socket = None
+
+        # Connect securely to Bitvavo, create the WebSocket and error callbacks.
+        def __init__(self):
+            self.bitvavo_engine = Bitvavo({
+                'APIKEY': self.api_key,
+                'APISECRET': self.api_secret
+            })
+            self.bitvavo_socket = self.bitvavo_engine.newWebsocket()
+            self.bitvavo_socket.setErrorCallback(self.error_callback)
+
+        # Handle errors.
+        def error_callback(self, error):
+            print("Add your error message.")
+            #print("Errors:", json.dumps(error, indent=2))
+
+        # Retrieve the data you need from Bitvavo in order to implement your
+        # trading logic. Use multiple workflows to return data to your
+        # callbacks.
+        def a_trading_strategy(self):
+            self.bitvavo_socket.ticker24h({}, self.a_trading_strategy_callback)
+
+        # In your app you analyse data returned by the trading strategy, then make
+        # calls to Bitvavo to respond to market conditions.
+        def a_trading_strategy_callback(self, response):
+            # Iterate through the markets
+            for market in response:
+
+                match market["market"]:
+                   case "ZRX-EUR":
+                        print("Eureka, the latest bid for ZRX-EUR is: ", market["bid"] )
+                        # Implement calculations for your trading logic.
+                        # If they are positive, place an order: For example:
+                        # self.bitvavo_socket.placeOrder("ZRX-EUR",
+                        #                               'buy',
+                        #                               'limit',
+                        #                               { 'amount': '1', 'price': '00001' },
+                        #                               self.order_placed_callback)
+                   case "a different market":
+                        print("do something else")
+                   case _:
+                        print("Not this one: ", market["market"])
+
+
+
+        def order_placed_callback(self, response):
+            # The order return parameters explain the quote and the fees for this trade.
+            print("Order placed:", json.dumps(response, indent=2))
+            # Add your business logic.
+
+
+        # Sockets are fast, but asynchronous. Keep the socket open while you are
+        # trading.
+        def wait_and_close(self):
+            # Bitvavo uses a weight based rate limiting system. Your app is limited to 1000 weight points per IP or
+            # API key per minute. The rate weighting for each endpoint is supplied in Bitvavo API documentation.
+            # This call returns the amount of points left. If you make more requests than permitted by the weight limit,
+            # your IP or API key is banned.
+            limit = self.bitvavo_engine.getRemainingLimit()
+            try:
+                while (limit > 0):
+                    time.sleep(0.5)
+                    limit = self.bitvavo_engine.getRemainingLimit()
+            except KeyboardInterrupt:
+                self.bitvavo_socket.closeSocket()
+
+
+    # Shall I re-explain main? Naaaaaaaaaa.
+    if __name__ == '__main__':
+        bvavo = BitvavoImplementation()
+        bvavo.a_trading_strategy()
+        bvavo.wait_and_close()
+    ```
+
+1. **Add security information**
+
+   You must supply your security information to trade on Bitvavo and see your
+   account information using the authenticate methods. Replace the values of
+   `api_key` and `api_secret` with your credentials from [Bitvavo
+   Dashboard](https://account.bitvavo.com/user/api).
+
+   You can retrieve public information such as available markets, assets and
+   current market without supplying your key and secret. However,
+   unauthenticated calls have lower rate limits based on your IP address, and
+   your account is blocked for longer if you exceed your limit.
+
+1. **Run your app**
+
+    - Command line warriors: `python3 <filename>`.
+    - IDE heroes: press the big green button.
+
+Your app connects to Bitvavo and returns a list the latest trade price for each
+market. You use this data to implement your trading logic.
+
+## About the SDK
+
+This section explains global concepts about Bitvavo SDK for Python.
+
+### Rate limit
+
+Bitvavo uses a weight based rate limiting system. Your app is limited to 1000
+weight points per IP or API key per minute. When you make a call to Bitvavo API,
+your remaining weight points are returned in the header of each REST request.
+
+Websocket methods do not return your returning weight points, you track your
+remaining weight points with a call to:
+
+```python
+limit = bitvavo.getRemainingLimit()
+```
+
+If you make more requests than permitted by the weight limit, your IP or API key
+is banned.
+
+The rate weighting for each endpoint is supplied in the [Bitvavo API
+documentation](https://docs.bitvavo.com/).
+
+### Requests
+
+For all methods, required parameters are passed as separate values, optional
+parameters are passed as a dictionary. Return parameters are in dictionary
+format: `response['<key>'] = '<value>'`. However, as a limit order requires more
+information than a market order, some optional parameters are required when you
+place an order.
+
+### Security
+
+You must set your API key and secret for authenticated endpoints, public
+endpoints do not require authentication.

bitvavo_api_upgraded-1.17.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+bitvavo_api_upgraded/__init__.py,sha256=IS9Ci2orRtYKHyFNXq_9qk9bB6zt4KU4tPbQAxkkCUM,72
+bitvavo_api_upgraded/bitvavo.py,sha256=-AgVq4hXHEsuQhCLEweyjJ_DhAPwbwtCeCPSNeweisA,125942
+bitvavo_api_upgraded/helper_funcs.py,sha256=4oBdQ1xB-C2XkQTmN-refzIzWfO-IUowDSWhOSFdCRU,3212
+bitvavo_api_upgraded/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+bitvavo_api_upgraded/settings.py,sha256=MalcO2buJso4NZktDRGGSZ7poF593ceb66zrmX-8dc4,1903
+bitvavo_api_upgraded/type_aliases.py,sha256=NAnMSk5n6SaEIvHFeSMKnXOxfOwnbFuEnRKaAXlcmYw,932
+bitvavo_api_upgraded-1.17.0.dist-info/METADATA,sha256=Csu9ntgiu7tVaEvKXJmBjrFEMAxlVfHhIHRlvYwflIo,11519
+bitvavo_api_upgraded-1.17.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+bitvavo_api_upgraded-1.17.0.dist-info/licenses/LICENSE.txt,sha256=hiFyor_njVlzVblnb-78mzx1Um3CGvuFxEH3YR735rc,744
+bitvavo_api_upgraded-1.17.0.dist-info/RECORD,,