jesse 2.2.0__tar.gz → 2.2.2__tar.gz

{jesse-2.2.0/jesse.egg-info → jesse-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jesse
-Version: 2.2.0
+Version: 2.2.2
 Summary: A trading framework for cryptocurrencies
 Home-page: https://jesse.trade
 Author: Saleh Mir

{jesse-2.2.0 → jesse-2.2.2}/jesse/controllers/backtest_controller.py

@@ -286,7 +286,7 @@ def get_backtest_session_chart_data(session_id: str, authorization: Optional[str
             'error': f'Session with ID {session_id} not found'
         }, status_code=404)
 
-    chart_data = jh.clean_infinite_values(json.loads(session.chart_data)) if session.chart_data else None
+    chart_data = jh.clean_nan_values(jh.clean_infinite_values(json.loads(session.chart_data))) if session.chart_data else None
 
     return JSONResponse({
         'chart_data': chart_data

{jesse-2.2.0 → jesse-2.2.2}/jesse/libs/dynamic_numpy_array/__init__.py

@@ -69,10 +69,16 @@ class DynamicNumpyArray:
     def append(self, item: np.ndarray) -> None:
         self.index += 1
 
-        # expand if the arr is almost full
-        if self.index != 0 and (self.index + 1) % self.bucket_size == 0:
-            new_bucket = np.zeros(self.shape)
-            self.array = np.concatenate((self.array, new_bucket), axis=0)
+        # Grow the buffer when full, doubling capacity (geometric growth) so
+        # that total bytes copied across all appends is O(N) rather than the
+        # O(N^2 / bucket_size) of linear-bucket growth via np.concatenate.
+        if self.index >= len(self.array):
+            new_size = max(len(self.array) * 2, max(self.bucket_size, 1))
+            new_shape = (new_size,) + tuple(self.array.shape[1:])
+            new_array = np.zeros(new_shape, dtype=self.array.dtype)
+            if self.index > 0:
+                new_array[:self.index] = self.array[:self.index]
+            self.array = new_array
 
         # drop N% of the beginning values to free memory
         if (
@@ -109,18 +115,21 @@ class DynamicNumpyArray:
         self.bucket_size = self.shape[0]
 
     def append_multiple(self, items: np.ndarray) -> None:
-        self.index += len(items)
-
-        # expand if the arr will be greater than the maximum
-        if self.index != 0 and (self.index + 1) >= len(self.array):
-            # in case the shape is smaller than  len(items)
-            if isinstance(self.shape, int):
-                shape = max(self.shape, len(items))
-            else:
-                shape = list(self.shape)
-                shape[0] = max(len(items), shape[0])
-            new_bucket = np.zeros(shape)
-            self.array = np.concatenate((self.array, new_bucket), axis=0)
+        n_new = len(items)
+        old_index = self.index
+        self.index += n_new
+
+        # Grow the buffer geometrically (double) when needed. Must accommodate
+        # `self.index + 1` total elements; ensure we double-or-better to avoid
+        # degrading to linear growth when many small batches are appended.
+        if self.index + 1 > len(self.array):
+            min_required = self.index + 1
+            new_size = max(min_required, len(self.array) * 2, max(self.bucket_size, 1))
+            new_shape = (new_size,) + tuple(self.array.shape[1:])
+            new_array = np.zeros(new_shape, dtype=self.array.dtype)
+            if old_index >= 0:
+                new_array[:old_index + 1] = self.array[:old_index + 1]
+            self.array = new_array
 
         # drop N% of the beginning values to free memory
         if (
@@ -132,7 +141,7 @@ class DynamicNumpyArray:
             self.index -= shift_num
             self.array = np_shift(self.array, -shift_num)
 
-        self.array[self.index - len(items) + 1 : self.index + 1] = items
+        self.array[self.index - n_new + 1 : self.index + 1] = items
 
     def delete(self, index: int, axis=None) -> None:
         self.array = np.delete(self.array, index, axis=axis)

{jesse-2.2.0 → jesse-2.2.2}/jesse/services/installer.py

@@ -49,17 +49,19 @@ def install(is_live_plugin_already_installed: bool, strict: bool):
     if not is_64_bit:
         raise NotImplementedError(f'Only 64-bit machines are supported')
 
-    is_arm = platform.machine().startswith('arm')
+    # platform.machine() returns 'arm64' on macOS but 'aarch64' on Linux (e.g. an
+    # arm64 Docker container on Apple Silicon), so both must be matched.
+    is_arm = platform.machine().lower() in ('arm64', 'aarch64')
     print('is_arm', is_arm)
-    # arm versions of linux and windows are not supported
-    if is_arm and (os_name in ['linux', 'windows']):
-        raise NotImplementedError(f'ARM versions of {os_name} are not supported. If you need them, send a request to contact@jesse.trade')
+    # ARM is supported on macOS and Linux; Windows on ARM is not.
+    if is_arm and os_name == 'windows':
+        raise NotImplementedError('ARM versions of Windows are not supported. If you need them, send a request to contact@jesse.trade')
 
     # format os_name to something acceptable for the API
     if os_name == 'mac':
         formatted_os_name = 'macOS - M1' if is_arm else 'macOS - Intel'
     elif os_name == 'linux':
-        formatted_os_name = 'Linux - x86_64'
+        formatted_os_name = 'Linux - aarch64' if is_arm else 'Linux - x86_64'
     # windows
     else:
         formatted_os_name = 'Windows 10 - 64 bit'

{jesse-2.2.0 → jesse-2.2.2}/jesse/services/order_service.py

@@ -55,9 +55,20 @@ def execute_order(order: Order, silent: bool = False) -> None:
     order.status = order_statuses.EXECUTED
     order.fee = order.fee or None
 
-    # if it's not live trading, we set the filled qty to the qty. 
+    # if it's not live trading, we set the filled qty to the qty.
     if not jh.is_livetrading():
-        order.filled_qty = order.qty
+        # a reduce_only order can only fill up to the size of the open position. If its
+        # stated qty exceeds the remaining position (e.g. a stop-loss left oversized after
+        # partial take-profits), the actual fill is capped to what closes the position.
+        if order.reduce_only:
+            p = store.positions.get_position(order.exchange, order.symbol)
+            position_qty = p.qty if p else 0.0
+            if position_qty != 0 and abs(order.qty) > abs(position_qty):
+                order.filled_qty = -position_qty
+            else:
+                order.filled_qty = order.qty
+        else:
+            order.filled_qty = order.qty
     
     # set order fee for non-live modes if not already set. In live trading, the fee is fetched by the exchange.
     if not jh.is_livetrading() and order.fee is None:

{jesse-2.2.0 → jesse-2.2.2}/jesse/services/position_service.py

@@ -177,7 +177,9 @@ def on_executed_order(position: Position, order: Order) -> None:
         price = order.price
 
         if position.exchange and position.exchange.type == 'futures':
-            position.exchange.charge_fee(qty * price)
+            # fee is charged on what actually filled, not the stated qty (a reduce_only
+            # order may fill less than its stated qty when it exceeds the open position).
+            position.exchange.charge_fee(order.filled_qty * price)
 
         # order opens position
         if position.qty == 0:

jesse-2.2.2/jesse/strategies/TestBaseAndQuoteAssetProperties/__init__.py

@@ -0,0 +1,17 @@
+from jesse.strategies import Strategy
+
+
+class TestBaseAndQuoteAssetProperties(Strategy):
+    def before(self) -> None:
+        if self.index == 0:
+            assert self.base_asset == 'BTC'
+            assert self.quote_asset == 'USDT'
+
+    def should_long(self) -> bool:
+        return False
+
+    def go_long(self):
+        pass
+
+    def should_cancel_entry(self) -> bool:
+        return False

jesse-2.2.2/jesse/strategies/TestOversizedReduceOnlyExitAccounting/__init__.py

@@ -0,0 +1,43 @@
+from jesse.strategies import Strategy
+from jesse.store import store
+
+
+class TestOversizedReduceOnlyExitAccounting(Strategy):
+    """
+    Reproduces the oversized reduce_only exit bug: when a reduce_only order's stated qty
+    exceeds the remaining position, the engine caps the actual fill but must account for
+    the *capped* qty (not the stated qty) in both the exit_price VWAP and the fee.
+
+    Down-trend prices walk 100 -> 11. We open long at 100 with TWO stop-loss tiers that
+    intentionally over-sum the position (1 + 2 = 3 > entry qty 2). tier1 (@90) reduces the
+    position to 1; when tier2 (@80, stated qty 2) later fires, reduce_only caps the actual
+    fill to the remaining 1.
+    """
+
+    def should_long(self):
+        return self.price == 100
+
+    def go_long(self):
+        if self.price == 100:
+            self.buy = 2, self.price
+
+    def on_open_position(self, order):
+        # stated qtys sum to 3 while the position is only 2 -> the @80 tier is oversized
+        # once the @90 tier has reduced the position.
+        self.stop_loss = [(1, 90), (2, 80)]
+
+    def on_close_position(self, order, closed_trade) -> None:
+        assert closed_trade.type == 'long'
+        assert closed_trade.entry_price == 100
+        assert closed_trade.qty == 2
+
+        # exit VWAP must weight the second leg by the ACTUAL filled 1, not the stated 2:
+        #   correct: (1*90 + 1*80) / (1 + 1) = 85
+        #   buggy:   (1*90 + 2*80) / (1 + 2) = 83.333...
+        assert round(closed_trade.exit_price, 8) == 85
+
+        # headline invariant: per-trade pnl must equal the real wallet balance change.
+        # this fails if either the exit_price VWAP or the fee is computed on the stated qty.
+        e = store.exchanges.get_exchange(self.exchange)
+        wallet_delta = e.wallet_balance - 10_000
+        assert round(closed_trade.pnl, 8) == round(wallet_delta, 8)

jesse-2.2.2/jesse/version.py

@@ -0,0 +1 @@
+__version__ = "2.2.2"

{jesse-2.2.0 → jesse-2.2.2/jesse.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jesse
-Version: 2.2.0
+Version: 2.2.2
 Summary: A trading framework for cryptocurrencies
 Home-page: https://jesse.trade
 Author: Saleh Mir

{jesse-2.2.0 → jesse-2.2.2}/jesse.egg-info/SOURCES.txt

@@ -944,6 +944,7 @@ jesse/strategies/TestAfterMethod/__init__.py
 jesse/strategies/TestAverageEntryPriceProperty/__init__.py
 jesse/strategies/TestBalanceAndFeeReductionWorksCorrectlyInSpotModeInBothBuyAndSellOrders/__init__.py
 jesse/strategies/TestBalancesAreHandledCorrectlyForCancellingOrdersInSpot/__init__.py
+jesse/strategies/TestBaseAndQuoteAssetProperties/__init__.py
 jesse/strategies/TestBeforeMethod/__init__.py
 jesse/strategies/TestBeforeTerminate/__init__.py
 jesse/strategies/TestCanCancelEntryOrdersAfterOpenPositionLong1/__init__.py
@@ -1005,6 +1006,7 @@ jesse/strategies/TestOrderIsTakeProfitProperty/__init__.py
 jesse/strategies/TestOrderPriceCannotBeGreaterThanZero/__init__.py
 jesse/strategies/TestOrderValueProperty/__init__.py
 jesse/strategies/TestOrdersAreSortedBeforeExecution/__init__.py
+jesse/strategies/TestOversizedReduceOnlyExitAccounting/__init__.py
 jesse/strategies/TestPortfolioValue/__init__.py
 jesse/strategies/TestPortfolioValueIncludesPositionValueAndOpenOrdersValue/__init__.py
 jesse/strategies/TestPositionExchangeTypeProperty1/__init__.py
@@ -1032,6 +1034,7 @@ tests/__init__.py
 tests/test_backtest.py
 tests/test_broker.py
 tests/test_candle_service.py
+tests/test_chart_data_serialization.py
 tests/test_completed_trade.py
 tests/test_conflicting_orders.py
 tests/test_dynamic_numpy_array.py

{jesse-2.2.0 → jesse-2.2.2}/setup.py

@@ -3,7 +3,7 @@ from pathlib import Path
 from setuptools import setup, find_packages
 
 # also change in version.py
-VERSION = "2.2.0"
+VERSION = "2.2.2"
 DESCRIPTION = "A trading framework for cryptocurrencies"
 BASE_DIR = Path(__file__).resolve().parent
 

{jesse-2.2.0 → jesse-2.2.2}/tests/test_broker.py

@@ -211,3 +211,63 @@ def test_should_not_submit_reduce_only_orders_when_position_is_closed():
 
     with pytest.raises(OrderNotAllowed):
         broker.reduce_position_at(1, 20, 20)
+
+
+def test_oversized_reduce_only_order_uses_actual_filled_qty():
+    """
+    Regression: when a reduce_only stop-loss is left with a stated qty larger than the
+    remaining position (e.g. a stop-loss not resized after a partial take-profit), the
+    engine caps the actual fill via reduce_only. The trade's exit_price VWAP and fee must
+    use that capped (actual) qty, not the stated qty — otherwise net_profit drifts below
+    the real wallet balance change.
+    """
+    set_up_with_fee(is_futures_trading=True)
+
+    starting_balance = exchange.wallet_balance
+    assert starting_balance == 1000
+
+    # open a long position of qty 1 @ 50
+    broker.buy_at_market(1)
+    for o in store.orders.to_execute:
+        order_service.execute_order(o)
+    store.orders.to_execute = []
+    assert position.qty == 1
+    assert position.entry_price == 50
+
+    # take partial profit: sell 0.7 @ 80 (limit), position -> 0.3
+    position.current_price = 50
+    tp_order = broker.reduce_position_at(0.7, 80, 50)
+    order_service.execute_order(tp_order)
+    position.current_price = 80
+    assert round(position.qty, 8) == 0.3
+
+    # submit an OVERSIZED stop-loss: stated qty 1 (full) while only 0.3 remains, @ 40
+    sl_order = broker.reduce_position_at(1, 40, 80)
+    assert sl_order.reduce_only is True
+    assert sl_order.qty == -1  # stated qty is oversized vs the remaining 0.3
+
+    # execute the stop -> reduce_only caps the actual fill to the remaining 0.3
+    order_service.execute_order(sl_order)
+    position.current_price = 40
+    assert position.is_close is True
+
+    # the actual fill is capped to the remaining position, not the stated qty
+    assert round(sl_order.filled_qty, 8) == -0.3
+
+    trade = store.closed_trades.trades[-1]
+
+    # exit_price VWAP must weight the SL leg by the ACTUAL 0.3, not the stated 1.0:
+    # (0.7*80 + 0.3*40) / (0.7+0.3) = 68, NOT (0.7*80 + 1.0*40) / 1.7 = 56.47
+    assert round(trade.exit_price, 8) == 68
+
+    # fee must be charged on the actual filled qty across all legs
+    expected_fee = (1 * 50 + 0.7 * 80 + 0.3 * 40) * 0.002
+    assert round(trade.fee, 8) == round(expected_fee, 8)
+
+    # headline check: per-trade net profit equals the real wallet balance change
+    wallet_delta = exchange.wallet_balance - starting_balance
+    assert round(trade.pnl, 8) == round(wallet_delta, 8)
+
+    # this test closes a position, so clean up the shared store to avoid leaking the
+    # closed trade into tests that assume an empty store at their start
+    store.reset()

jesse-2.2.2/tests/test_chart_data_serialization.py

@@ -0,0 +1,84 @@
+import json
+import math
+
+import numpy as np
+import pytest
+
+import jesse.helpers as jh
+
+
+# This mirrors what Starlette's JSONResponse does internally: it renders with
+# `allow_nan=False`, which raises `ValueError: Out of range float values are not
+# JSON compliant` if NaN / Infinity / -Infinity reach the encoder. The
+# `/backtest/sessions/{id}/chart-data` endpoint hit exactly this when a strategy's
+# `after()` produced NaN values for a custom chart line (GitHub issue #563).
+def _render_like_jsonresponse(content):
+    return json.dumps(content, ensure_ascii=False, allow_nan=False)
+
+
+def _sample_chart_data():
+    """
+    Approximates the structure assembled in backtest_mode for the frontend:
+    custom lines added from a strategy's `after()` hook may legitimately contain
+    NaN (e.g. an indicator that is not warmed up yet) or +/-inf (e.g. division
+    by zero).
+    """
+    return {
+        'add_line_to_candle_chart': {
+            'my_line': [
+                {'time': 1, 'value': 10.0},
+                {'time': 2, 'value': float('nan')},
+                {'time': 3, 'value': float('inf')},
+                {'time': 4, 'value': float('-inf')},
+                {'time': 5, 'value': np.float64('nan')},
+                {'time': 6, 'value': 20.5},
+            ]
+        },
+        'add_extra_line_chart': [np.float64('nan'), 1.0, np.int64(3)],
+        'flag': True,
+    }
+
+
+def test_raw_chart_data_with_nan_is_not_json_compliant():
+    """Without sanitizing, the data reproduces the issue #563 failure."""
+    raw = _sample_chart_data()
+    with pytest.raises(ValueError):
+        _render_like_jsonresponse(raw)
+
+
+def test_cleaned_chart_data_is_json_compliant():
+    """
+    The chart-data endpoint must strip BOTH NaN and infinite values before
+    handing the payload to JSONResponse. `clean_infinite_values` alone leaves
+    NaN behind, which was the root cause of issue #563.
+    """
+    raw = _sample_chart_data()
+
+    # Exactly the composition the controller now applies.
+    cleaned = jh.clean_nan_values(jh.clean_infinite_values(raw))
+
+    # Must not raise anymore.
+    serialized = _render_like_jsonresponse(cleaned)
+    reloaded = json.loads(serialized)
+
+    line = reloaded['add_line_to_candle_chart']['my_line']
+    assert line[0]['value'] == 10.0          # untouched valid float
+    assert line[1]['value'] is None          # NaN -> None
+    assert line[2]['value'] is None          # +inf -> None
+    assert line[3]['value'] is None          # -inf -> None
+    assert line[4]['value'] is None          # numpy NaN -> None
+    assert line[5]['value'] == 20.5          # untouched valid float
+
+    extra = reloaded['add_extra_line_chart']
+    assert extra[0] is None                  # numpy NaN -> None
+    assert extra[1] == 1.0
+    assert extra[2] == 3                      # numpy int preserved
+    assert reloaded['flag'] is True          # bool preserved (not coerced to int)
+
+
+def test_clean_infinite_values_alone_leaves_nan():
+    """Regression guard documenting why both cleaners are required."""
+    only_inf_cleaned = jh.clean_infinite_values({'v': float('nan')})
+    assert math.isnan(only_inf_cleaned['v'])
+    with pytest.raises(ValueError):
+        _render_like_jsonresponse(only_inf_cleaned)

jesse-2.2.2/tests/test_dynamic_numpy_array.py

@@ -0,0 +1,254 @@
+import numpy as np
+import pytest
+
+from jesse.libs import DynamicNumpyArray
+
+
+def test_append():
+    a = DynamicNumpyArray((10, 6))
+    a.append(np.array([1, 2, 3, 4, 5, 6]))
+    assert a.index == 0
+    assert a.array[0][0] == 1
+    assert a.array[0][1] == 2
+    assert a.array[0][2] == 3
+    assert a.array[0][3] == 4
+    assert a.array[0][4] == 5
+    assert a.array[0][5] == 6
+
+    a.append(np.array([7, 8, 9, 10, 11, 12]))
+    assert a.index == 1
+    assert a.array[1][0] == 7
+    assert a.array[1][1] == 8
+    assert a.array[1][2] == 9
+    assert a.array[1][3] == 10
+    assert a.array[1][4] == 11
+    assert a.array[1][5] == 12
+
+
+def test_flush():
+    a = DynamicNumpyArray((10, 6))
+    a.append(np.array([1, 2, 3, 4, 5, 6]))
+    a.append(np.array([7, 8, 9, 10, 11, 12]))
+    assert a.index == 1
+    assert a.array[0][0] == 1
+    assert a.array[1][0] == 7
+
+    a.flush()
+
+    assert a.index == -1
+    assert a.array[0][0] == 0
+    assert a.array[1][0] == 0
+
+
+def test_get_last_item():
+    a = DynamicNumpyArray((10, 6))
+
+    with pytest.raises(IndexError):
+        a.get_last_item()
+
+    a.append(np.array([1, 2, 3, 4, 5, 6]))
+    a.append(np.array([7, 8, 9, 10, 11, 12]))
+    assert a.index == 1
+    assert a.array[0][0] == 1
+    assert a.array[1][0] == 7
+
+    np.testing.assert_array_equal(a.get_last_item(), np.array([7, 8, 9, 10, 11, 12]))
+
+
+def test_get_past_item():
+    a = DynamicNumpyArray((10, 6))
+
+    with pytest.raises(IndexError):
+        a.get_past_item(1)
+
+    a.append(np.array([1, 2, 3, 4, 5, 6]))
+    a.append(np.array([7, 8, 9, 10, 11, 12]))
+    assert a.index == 1
+    assert a.array[0][0] == 1
+    assert a.array[1][0] == 7
+
+    np.testing.assert_array_equal(a.get_past_item(1), np.array([1, 2, 3, 4, 5, 6]))
+
+    with pytest.raises(IndexError):
+        a.get_past_item(2)
+
+
+def test_get_item():
+    a = DynamicNumpyArray((10, 6))
+
+    # test getting while array is empty
+    with pytest.raises(IndexError):
+        var = a[0]
+
+    a.append(np.array([1, 2, 3, 4, 5, 6]))
+    a.append(np.array([7, 8, 9, 10, 11, 12]))
+    assert a.index == 1
+    assert a.array[0][0] == 1
+    assert a.array[1][0] == 7
+
+    np.testing.assert_array_equal(a[0], np.array([1, 2, 3, 4, 5, 6]))
+    np.testing.assert_array_equal(a[1], np.array([7, 8, 9, 10, 11, 12]))
+
+    # test with an index that is out of range
+    with pytest.raises(IndexError):
+        var = a[2]
+
+
+def test_array_size_increases():
+    """Verify the buffer grows to accommodate appends.
+
+    The exact post-grow shape is an implementation detail (linear-bucket vs
+    geometric); what matters behaviorally is that all appended values are
+    retained correctly and the buffer has at least enough capacity.
+    """
+    a = DynamicNumpyArray((3, 6))
+
+    assert a.array.shape == (3, 6)
+
+    a.append(np.array([1, 2, 3, 4, 5, 6]))
+    a.append(np.array([7, 8, 9, 10, 11, 12]))
+    a.append(np.array([13, 14, 15, 16, 17, 18]))
+    assert a.array.shape[0] >= 3
+    assert a.array.shape[1] == 6
+    assert a.index == 2
+    np.testing.assert_array_equal(a[0], np.array([1, 2, 3, 4, 5, 6]))
+    np.testing.assert_array_equal(a[2], np.array([13, 14, 15, 16, 17, 18]))
+
+    a.append(np.array([19, 20, 21, 22, 23, 24]))
+    a.append(np.array([25, 26, 27, 28, 29, 30]))
+    a.append(np.array([31, 32, 33, 34, 35, 36]))
+    assert a.array.shape[0] >= 6
+    assert a.array.shape[1] == 6
+    assert a.index == 5
+    np.testing.assert_array_equal(a[5], np.array([31, 32, 33, 34, 35, 36]))
+
+
+def test_geometric_growth_pattern():
+    """The number of buffer reallocations across N appends should be O(log N),
+    not O(N/bucket_size). This guards against accidental regression to linear
+    growth (which produces O(N^2) total memcpy on long backtests)."""
+    a = DynamicNumpyArray((4, 6))
+    n_appends = 5000
+
+    sizes_seen = [a.array.shape[0]]
+    for i in range(n_appends):
+        a.append(np.array([i, i + 1, i + 2, i + 3, i + 4, i + 5]))
+        if a.array.shape[0] != sizes_seen[-1]:
+            sizes_seen.append(a.array.shape[0])
+
+    # log2(5000/4) ≈ 10.3 — we should see at most ~12 distinct sizes.
+    assert len(sizes_seen) <= 14, (
+        f"too many growths ({len(sizes_seen)}): {sizes_seen}"
+    )
+    # Each growth at least 1.5× the prior — prevents accidental linear growth
+    for prev, nxt in zip(sizes_seen, sizes_seen[1:]):
+        assert nxt >= prev * 1.5, (
+            f"growth from {prev} to {nxt} is sub-geometric"
+        )
+
+    # Spot-check correctness — appends should be intact in order
+    np.testing.assert_array_equal(a[0], np.array([0, 1, 2, 3, 4, 5]))
+    np.testing.assert_array_equal(a[2500], np.array([2500, 2501, 2502, 2503, 2504, 2505]))
+    np.testing.assert_array_equal(a[n_appends - 1], np.array([4999, 5000, 5001, 5002, 5003, 5004]))
+
+
+def test_append_multiple_grows_geometrically():
+    """append_multiple should also use geometric growth and produce identical
+    final state to the equivalent sequence of append() calls."""
+    via_multiple = DynamicNumpyArray((10, 6))
+    via_single = DynamicNumpyArray((10, 6))
+
+    rng = np.random.default_rng(seed=42)
+    n_batches = 30
+    batch_size = 25
+    for _ in range(n_batches):
+        batch = rng.standard_normal((batch_size, 6))
+        via_multiple.append_multiple(batch)
+        for row in batch:
+            via_single.append(row)
+
+    assert via_multiple.index == via_single.index
+    np.testing.assert_array_equal(
+        via_multiple.array[:via_multiple.index + 1],
+        via_single.array[:via_single.index + 1],
+    )
+
+
+def test_append_multiple_varied_batch_sizes():
+    """append_multiple must hold the correct valid data regardless of batch
+    sizes relative to the bucket size (small, equal, and much larger batches),
+    including a single batch larger than the current capacity."""
+    a = DynamicNumpyArray((10, 6))
+    expected = []
+    rng = np.random.default_rng(seed=7)
+    for bs in [1, 5, 10, 23, 100, 3, 50, 7, 200]:
+        batch = rng.standard_normal((bs, 6))
+        a.append_multiple(batch)
+        expected.extend(batch.tolist())
+
+    assert a.index == len(expected) - 1
+    np.testing.assert_array_equal(a.array[:a.index + 1], np.array(expected))
+    # capacity must always be large enough to hold the valid region
+    assert a.array.shape[0] >= a.index + 1
+
+
+def test_geometric_growth_never_overflows():
+    """After every append the write index must remain within capacity — guards
+    against an off-by-one in the doubling condition."""
+    a = DynamicNumpyArray((4, 6))
+    for i in range(3000):
+        a.append(np.arange(6, dtype=float) + i)
+        assert a.index < a.array.shape[0]
+    np.testing.assert_array_equal(a[2999], np.arange(6, dtype=float) + 2999)
+
+
+def test_append_multiple_then_append_no_overflow():
+    """Mirror the real backtest flow: candles are warmed up in chunks via
+    append_multiple() and then streamed in one-by-one via append() on the SAME
+    storage (see candle_service.add_multiple_1m_candles -> add_candle).
+
+    The previous linear-bucket implementation assumed capacity stayed a
+    multiple of bucket_size, an invariant append_multiple could break, so a
+    chunked warmup (e.g. 1500 + 800 into a bucket_size=1000 array) followed by
+    single appends overflowed with an IndexError. Geometric growth keys off the
+    actual capacity, so it must keep correct data without ever overflowing.
+    """
+    a = DynamicNumpyArray((1000, 6))
+    expected = []
+
+    # chunked warmup via append_multiple
+    for chunk in (1500, 800):
+        batch = np.arange(len(expected) * 6, (len(expected) + chunk) * 6, dtype=float).reshape(chunk, 6)
+        a.append_multiple(batch)
+        expected.extend(batch.tolist())
+
+    # then stream single candles in, well past the warmed-up capacity
+    for i in range(5000):
+        row = np.full(6, 1_000_000.0 + i)
+        a.append(row)
+        expected.append(row.tolist())
+        # the write index must always stay within the allocated buffer
+        assert a.index < a.array.shape[0]
+
+    assert a.index == len(expected) - 1
+    np.testing.assert_array_equal(a.array[:a.index + 1], np.array(expected))
+    np.testing.assert_array_equal(a[0], np.array([0, 1, 2, 3, 4, 5], dtype=float))
+    np.testing.assert_array_equal(a[-1], np.full(6, 1_000_000.0 + 4999))
+
+
+def test_drop_at():
+    a = DynamicNumpyArray((100, 6), drop_at=6)
+
+    # add 5 items
+    a.append(np.array([1, 2, 3, 4, 5, 6]))
+    a.append(np.array([7, 8, 9, 10, 11, 12]))
+    a.append(np.array([13, 14, 15, 16, 17, 18]))
+    a.append(np.array([19, 20, 21, 22, 23, 24]))
+    a.append(np.array([25, 26, 27, 28, 29, 30]))
+    assert a.get_last_item()[0] == 25
+    assert a[0][0] == 1
+
+    # add 6th item. when it reaches the drop_at limit, it should drop drop_at/2 items
+    a.append(np.array([31, 32, 33, 34, 35, 36]))
+    assert a[0][0] == 19
+