bitvavo-api-upgraded 2.0.0__py3-none-any.whl → 2.3.0__py3-none-any.whl

{bitvavo_api_upgraded-2.0.0.dist-info → bitvavo_api_upgraded-2.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: bitvavo-api-upgraded
-Version: 2.0.0
+Version: 2.3.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>
@@ -8,7 +8,6 @@ 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)
@@ -22,16 +21,40 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python
 Classifier: Typing :: Typed
+Requires-Dist: deprecated>=1.2.18
 Requires-Dist: pydantic-settings==2.*,>=2.6
 Requires-Dist: requests==2.*,>=2.26
 Requires-Dist: structlog>=21.5,==25.*
 Requires-Dist: websocket-client==1.*,>=1.2
+Requires-Dist: cudf-cu12>=24.0.0 ; extra == 'cudf'
+Requires-Dist: narwhals>=2.0.0 ; extra == 'cudf'
+Requires-Dist: narwhals[dask]>=2.0.0 ; extra == 'dask'
+Requires-Dist: narwhals[duckdb]>=2.0.0 ; extra == 'duckdb'
+Requires-Dist: narwhals[ibis]>=2.0.0 ; extra == 'ibis'
+Requires-Dist: narwhals[modin]>=2.0.0 ; extra == 'modin'
+Requires-Dist: narwhals[pandas]>=2.0.0 ; extra == 'pandas'
+Requires-Dist: narwhals[polars]>=2.0.0 ; extra == 'polars'
+Requires-Dist: narwhals[pyarrow]>=2.0.0 ; extra == 'pyarrow'
+Requires-Dist: narwhals[pyspark]>=2.0.0 ; extra == 'pyspark'
+Requires-Dist: narwhals[pyspark-connect]>=2.0.0 ; extra == 'pyspark-connect'
+Requires-Dist: narwhals[sqlframe]>=2.0.0 ; extra == 'sqlframe'
 Maintainer: NostraDavid
 Maintainer-email: NostraDavid <55331731+NostraDavid@users.noreply.github.com>
 Requires-Python: >=3.9
 Project-URL: changelog, https://github.com/Thaumatorium/bitvavo-api-upgraded/blob/master/CHANGELOG.md
 Project-URL: homepage, https://github.com/Thaumatorium/bitvavo-api-upgraded
 Project-URL: repository, https://github.com/Thaumatorium/bitvavo-api-upgraded
+Provides-Extra: cudf
+Provides-Extra: dask
+Provides-Extra: duckdb
+Provides-Extra: ibis
+Provides-Extra: modin
+Provides-Extra: pandas
+Provides-Extra: polars
+Provides-Extra: pyarrow
+Provides-Extra: pyspark
+Provides-Extra: pyspark-connect
+Provides-Extra: sqlframe
 Description-Content-Type: text/markdown
 
 # Bitvavo API (upgraded)
@@ -44,6 +67,46 @@ A **typed, tested, and enhanced** Python wrapper for the Bitvavo cryptocurrency
 pip install bitvavo_api_upgraded
 ```
 
+### Optional Dataframe Support
+
+This package supports multiple dataframe libraries via [Narwhals](https://narwhals-dev.github.io/narwhals/), providing a unified interface across:
+
+- **pandas** - The most popular Python data analysis library
+- **polars** - Fast, memory-efficient DataFrames in Rust
+- **cuDF** - GPU-accelerated DataFrames (NVIDIA RAPIDS)
+- **modin** - Distributed pandas on Ray/Dask
+- **PyArrow** - In-memory columnar data format
+- **Dask** - Parallel computing with task scheduling
+- **DuckDB** - In-process analytical database
+- **Ibis** - Portable analytics across backends
+- **PySpark** - Distributed data processing
+- **PySpark Connect** - Client for remote Spark clusters
+- **SQLFrame** - SQL-like operations on DataFrames
+
+Install with your preferred dataframe library:
+
+```bash
+# Basic installation (dict output only)
+pip install bitvavo_api_upgraded
+
+# With pandas support
+pip install bitvavo_api_upgraded[pandas]
+
+# With polars support
+pip install bitvavo_api_upgraded[polars]
+
+# With multiple libraries
+pip install bitvavo_api_upgraded[pandas,polars,pyarrow]
+
+# With GPU acceleration (cuDF)
+pip install bitvavo_api_upgraded[cudf]
+
+# With distributed computing (Dask)
+pip install bitvavo_api_upgraded[dask]
+
+# Note: polars-gpu support will be available in a future release
+```
+
 Scroll down for detailed usage examples and configuration instructions.
 
 ## What Makes This "Upgraded"?
@@ -56,14 +119,19 @@ This wrapper improves upon the official Bitvavo SDK with:
 - 🔄 **Up-to-date API compliance** including MiCA regulatory requirements
 - 📚 **Enhanced documentation** with examples and clear usage patterns
 - 🐍 **Modern Python support** (3.9+, dropped EOL versions)
+- 🔑 **Multi-key & keyless support** for enhanced rate limiting and public access
 - ⚡ **Better error handling** and rate limiting
 - 🔧 **Developer-friendly tooling** (ruff, mypy, pre-commit hooks)
+- 📊 **Unified dataframe support** via Narwhals (pandas, polars, cuDF, modin, PyArrow, Dask, DuckDB, Ibis, PySpark, SQLFrame)
 
 ## Features
 
 ### Full API Coverage
 
 - ✅ All REST endpoints (public and private)
+- ✅ **Multiple API key support** with automatic load balancing
+- ✅ **Keyless access** for public endpoints without authentication
+- ✅ **Comprehensive dataframe support** via Narwhals (pandas, polars, cuDF, modin, PyArrow, Dask, DuckDB, Ibis, PySpark, and more)
 - ✅ WebSocket support with reconnection logic
 - ✅ Rate limiting with automatic throttling
 - ✅ MiCA compliance reporting endpoints
@@ -79,6 +147,7 @@ This wrapper improves upon the official Bitvavo SDK with:
 ### Production Ready
 
 - ✅ Automatic rate limit management
+- ✅ Multi-key failover support
 - ✅ Connection retry logic
 - ✅ Proper error responses
 - ✅ Memory efficient WebSocket handling
@@ -88,8 +157,19 @@ This wrapper improves upon the official Bitvavo SDK with:
 Create a `.env` file in your project root:
 
 ```env
+# Single API key (traditional)
 BITVAVO_APIKEY=your-api-key-here
 BITVAVO_APISECRET=your-api-secret-here
+
+# Multiple API keys (for rate limiting)
+# BITVAVO_APIKEYS='[{"key": "key1", "secret": "secret1"}, {"key": "key2", "secret": "secret2"}]'
+
+# Keyless access (public endpoints only)
+BITVAVO_PREFER_KEYLESS=true
+
+# Enhanced settings
+BITVAVO_API_UPGRADED_DEFAULT_RATE_LIMIT=750
+BITVAVO_API_UPGRADED_PREFER_KEYLESS=false
 ```
 
 Then use the settings:
@@ -106,6 +186,17 @@ bitvavo = Bitvavo({
 # Option 2: Auto-load from .env
 settings = BitvavoSettings()
 bitvavo = Bitvavo(settings.model_dump())
+
+# Option 3: Multiple API keys
+bitvavo = Bitvavo({
+    'APIKEYS': [
+        {'key': 'key1', 'secret': 'secret1'},
+        {'key': 'key2', 'secret': 'secret2'}
+    ]
+})
+
+# Option 4: Keyless (public endpoints only)
+bitvavo = Bitvavo({'PREFER_KEYLESS': True})
 ```
 
 ## WebSocket Usage
@@ -135,6 +226,66 @@ except KeyboardInterrupt:
     ws.closeSocket()
 ```
 
+## Multi-Key & Keyless Examples
+
+### Multiple API Keys for Rate Limiting
+
+```python
+from bitvavo_api_upgraded import Bitvavo
+
+# Configure multiple API keys
+bitvavo = Bitvavo({
+    'APIKEYS': [
+        {'key': 'key1', 'secret': 'secret1'},
+        {'key': 'key2', 'secret': 'secret2'},
+        {'key': 'key3', 'secret': 'secret3'}
+    ]
+})
+
+# API automatically balances load across keys
+balance = bitvavo.balance({})  # Uses least-used key
+orders = bitvavo.getOrders('BTC-EUR', {})  # May use different key
+trades = bitvavo.getTrades('BTC-EUR', {})  # Automatic failover if rate limit reached
+```
+
+### Keyless Access (Public Endpoints)
+
+```python
+from bitvavo_api_upgraded import Bitvavo
+
+# No API keys needed for public data
+bitvavo = Bitvavo({'PREFER_KEYLESS': True})
+
+# These work without authentication and don't count against your rate limits
+markets = bitvavo.markets({})
+ticker = bitvavo.ticker24h({'market': 'BTC-EUR'})
+trades = bitvavo.publicTrades('BTC-EUR', {})
+book = bitvavo.book('BTC-EUR', {})
+candles = bitvavo.candles('BTC-EUR', '1h', {})
+
+# Private endpoints will still require authentication
+# account = bitvavo.account()  # This would fail without API keys
+```
+
+### Hybrid Configuration
+
+```python
+# Combine keyless preference with API keys for optimal performance
+bitvavo = Bitvavo({
+    'APIKEYS': [
+        {'key': 'key1', 'secret': 'secret1'},
+        {'key': 'key2', 'secret': 'secret2'}
+    ],
+    'PREFER_KEYLESS': True  # Use keyless for public endpoints, API keys for private
+})
+
+# Public calls use keyless (no rate limit impact)
+markets = bitvavo.markets({})
+
+# Private calls use API keys with load balancing
+balance = bitvavo.balance({})
+```
+
 ## API Examples
 
 ### Public Endpoints (No Authentication)
@@ -213,6 +364,74 @@ book_report = bitvavo.reportBook(
 history = bitvavo.accountHistory(options={})
 ```
 
+### Dataframe Usage
+
+The library supports multiple dataframe formats for tabular data like market data, asset information, and candlestick data:
+
+```python
+from bitvavo_api_upgraded import Bitvavo
+
+bitvavo = Bitvavo({'APIKEY': 'key', 'APISECRET': 'secret'})
+
+# Get markets as different dataframe types
+markets_dict = bitvavo.markets({}, output_format='dict')         # Default dict format
+markets_pandas = bitvavo.markets({}, output_format='pandas')     # Pandas DataFrame
+markets_polars = bitvavo.markets({}, output_format='polars')     # Polars DataFrame
+markets_pyarrow = bitvavo.markets({}, output_format='pyarrow')   # PyArrow Table
+
+# Get assets information as dataframes
+assets_cudf = bitvavo.assets(
+    {},
+    output_format='cudf'  # GPU-accelerated with cuDF
+)
+
+# Get candlestick data with distributed processing
+candles_dask = bitvavo.candles(
+    'BTC-EUR',
+    '1h',
+    {'limit': 100},
+    output_format='dask'  # Distributed with Dask
+)
+
+# Get public trades with analytical databases
+trades_duckdb = bitvavo.publicTrades(
+    'BTC-EUR',
+    {'limit': 1000},
+    output_format='duckdb'  # DuckDB relation
+)
+
+# Account balance with PySpark for big data processing
+balance_spark = bitvavo.balance(
+    {},
+    output_format='pyspark'  # PySpark DataFrame
+)
+```
+
+### Working with Different Libraries
+
+```python
+# Pandas example - most common
+import pandas as pd
+df = bitvavo.markets({}, output_format='pandas')
+print(df.describe())
+df.to_csv('markets.csv')
+
+# Polars example - faster for large datasets
+import polars as pl
+df = bitvavo.candles('BTC-EUR', '1h', {'limit': 1000}, output_format='polars')
+result = df.filter(pl.col('close') > 50000).select(['timestamp', 'close'])
+
+# DuckDB example - analytical queries
+import duckdb
+rel = bitvavo.publicTrades('BTC-EUR', {'limit': 10000}, output_format='duckdb')
+high_volume_trades = duckdb.query("SELECT * FROM rel WHERE amount > 1.0")
+
+# PyArrow example - columnar data
+import pyarrow as pa
+table = bitvavo.assets({}, output_format='pyarrow')
+df = table.to_pandas()  # Convert to pandas when needed
+```
+
 ## Error Handling
 
 ```python
@@ -247,11 +466,28 @@ print(f"Remaining API calls: {remaining}")
 if remaining > 10:
     # Safe to make API calls
     response = bitvavo.balance({})
+
+# With multiple API keys, rate limits are distributed
+bitvavo_multi = Bitvavo({
+    'APIKEYS': [
+        {'key': 'key1', 'secret': 'secret1'},
+        {'key': 'key2', 'secret': 'secret2'}
+    ]
+})
+
+# Each key gets its own rate limit pool
+# Automatic failover when one key hits limits
+for i in range(2000):  # Would exceed single key limit
+    markets = bitvavo_multi.markets({})  # Automatically switches keys
+
+# Keyless calls don't count against authenticated rate limits
+bitvavo_keyless = Bitvavo({'PREFER_KEYLESS': True})
+markets = bitvavo_keyless.markets({})  # Uses public rate limit pool
 ```
 
 ## Development & Contributing
 
-```shell
+````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)"
@@ -283,7 +519,7 @@ uv run mypy src/
 # Linting and formatting
 uv run ruff check
 uv run ruff format
-```
+````
 
 ### Project Structure
 
@@ -317,6 +553,9 @@ This package includes a `py.typed` file to enable type checking. Reference: [Don
 
 - Import: `from bitvavo_api_upgraded import Bitvavo` (instead of `from python_bitvavo_api.bitvavo import Bitvavo`)
 - **Breaking Change**: Trading operations require `operatorId` parameter
+- **New**: Multiple API key support for better rate limiting
+- **New**: Keyless access for public endpoints
+- **New**: Comprehensive dataframe support
 - Enhanced error handling and type safety
 - Better configuration management with `.env` support
 
@@ -325,7 +564,30 @@ This package includes a `py.typed` file to enable type checking. Reference: [Don
 1. Update import statements
 2. Add `operatorId` to trading method calls
 3. Optional: Migrate to `.env` configuration
-4. Enjoy improved type hints and error handling!
+4. Optional: Configure multiple API keys for better rate limits
+5. Optional: Enable keyless mode for public endpoint efficiency
+6. Enjoy improved type hints and error handling!
+
+### Enhanced Features (Optional)
+
+```python
+# Traditional single key (works as before)
+bitvavo = Bitvavo({'APIKEY': 'key', 'APISECRET': 'secret'})
+
+# New: Multiple keys for rate limiting
+bitvavo = Bitvavo({
+    'APIKEYS': [
+        {'key': 'key1', 'secret': 'secret1'},
+        {'key': 'key2', 'secret': 'secret2'}
+    ]
+})
+
+# New: Keyless for public endpoints
+bitvavo = Bitvavo({'PREFER_KEYLESS': True})
+
+# New: Dataframe support
+markets_df = bitvavo.markets({}, output_format='pandas')
+```
 
 ---
 
@@ -388,105 +650,105 @@ 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/):
+   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
-    ```
+   ```shell
+   python -m pip install python_bitvavo_api
+   ```
 
-    If you installed from `test.pypi.com`, update the requests library: `pip
-    install --upgrade  requests`.
+   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()
-    ```
+   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**
 
@@ -502,8 +764,8 @@ Want to quickly make a trading app? Here you go:
 
 1. **Run your app**
 
-    - Command line warriors: `python3 <filename>`.
-    - IDE heroes: press the big green button.
+   - 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.

bitvavo_api_upgraded-2.3.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+bitvavo_api_upgraded/__init__.py,sha256=J_HdGBmZOfb1eOydaxsPmXfOIZ58hVa1qAfE6QErUHs,301
+bitvavo_api_upgraded/bitvavo.py,sha256=0zg4cTU_UAH9d0BcENbvvvK-0T2YurxGIMu-jXlGDSo,178030
+bitvavo_api_upgraded/dataframe_utils.py,sha256=Jf-2zkYuK5Zs9kiMFJlCmO-OykjZyFIvW2aaMJYPUpo,5792
+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=br1oqN3K8OoimmKa1JlvzMgpYNHfr2kK2f14tC72dl8,5311
+bitvavo_api_upgraded/type_aliases.py,sha256=EOd3LhruyM1aZYn4xyKYhdoSql8mZH88acN0qGzMMck,1992
+bitvavo_api_upgraded-2.3.0.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
+bitvavo_api_upgraded-2.3.0.dist-info/METADATA,sha256=PR1cQJzAFKh8OyXG_5F4IUCDDmNWA7Pb4eBm_XPkE9k,25512
+bitvavo_api_upgraded-2.3.0.dist-info/RECORD,,

{bitvavo_api_upgraded-2.0.0.dist-info → bitvavo_api_upgraded-2.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: uv 0.8.9
+Generator: uv 0.8.13
 Root-Is-Purelib: true
 Tag: py3-none-any

bitvavo_api_upgraded-2.0.0.dist-info/RECORD

@@ -1,9 +0,0 @@
-bitvavo_api_upgraded/__init__.py,sha256=0922b82678a737a9f1314aa84fe4bf565f5425ce0d3aac1f6db65ff909efa68e,222
-bitvavo_api_upgraded/bitvavo.py,sha256=e4d986ae3529b082d329f1da51027e7400f7a342faa023e037181dceb439d481,134183
-bitvavo_api_upgraded/helper_funcs.py,sha256=e2805d435c41f82d979104e637eade7f323359f3be214a300d25a139215d0915,3212
-bitvavo_api_upgraded/py.typed,sha256=e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855,0
-bitvavo_api_upgraded/settings.py,sha256=647dac47d894c8e0bf9526aa993e74c04467814ba86efbbc7744cb8983799d38,2266
-bitvavo_api_upgraded/type_aliases.py,sha256=3409cc4a4e67e9268422f1c579230a9d73b17cec276c5b849d129a01795c998c,932
-bitvavo_api_upgraded-2.0.0.dist-info/WHEEL,sha256=2b400f346628f0064eb5bbf656b39df8dfcb092437ab08244409d295749b81a3,78
-bitvavo_api_upgraded-2.0.0.dist-info/METADATA,sha256=e7e9d2261c0af757cfe323dc911012b2f834a030848684ac6d18585911eb6691,17102
-bitvavo_api_upgraded-2.0.0.dist-info/RECORD,,