quantex 0.4.0__tar.gz → 0.4.2__tar.gz

{quantex-0.4.0 → quantex-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: quantex
-Version: 0.4.0
+Version: 0.4.2
 Summary: A simple quant strategy creation and backtesting package.
 License: MIT
 Author: Daniel Green
@@ -26,9 +26,9 @@ It gives you a small set of building blocks:
 
 - [`Strategy`](src/quantex/strategy.py:9) for your trading rules
 - [`DataSource`](src/quantex/datasource.py:6) plus [`CSVDataSource`](src/quantex/datasource.py:194) and [`ParquetDataSource`](src/quantex/datasource.py:228) for OHLCV market data
-- [`Broker`](src/quantex/broker.py:113) objects, created automatically per symbol, for order placement and position state
-- [`SimpleBacktester`](src/quantex/backtester.py:356) for simulation and parameter search
-- [`BacktestReport`](src/quantex/backtester.py:188) for results, equity history, and summary statistics
+- [`Broker`](src/quantex/broker/broker.py:113) objects, created automatically per symbol, for order placement and position state
+- [`SimpleBacktester`](src/quantex/backtester/backtester.py:26) for simulation and parameter search
+- [`BacktestReport`](src/quantex/backtester/reports.py:4) for results, equity history, and summary statistics
 
 The project is intentionally small. It does not try to be a full research platform, portfolio database, or live-trading engine. Instead, it focuses on a straightforward workflow: load historical bars, define strategy logic, simulate orders, and inspect the results.
 
@@ -48,8 +48,8 @@ At runtime, a typical Quantex workflow looks like this:
 2. In [`Strategy.init()`](src/quantex/strategy.py:52), attach one or more data sources with [`Strategy.add_data()`](src/quantex/strategy.py:98).
 3. Still in [`Strategy.init()`](src/quantex/strategy.py:52), build indicator arrays with the built-in indicator catalog on `self.ta` or the package-level [`indicators`](src/quantex/indicators.py), then register them with [`Strategy.Indicator()`](src/quantex/strategy.py:126).
 4. In [`Strategy.next()`](src/quantex/strategy.py:71), read the current bar through properties such as [`DataSource.COpen`](src/quantex/datasource.py:145) and [`DataSource.CClose`](src/quantex/datasource.py:175), then place orders through the broker stored in [`Strategy.positions`](src/quantex/strategy.py:47).
-5. Run the strategy with [`SimpleBacktester.run()`](src/quantex/backtester.py:414).
-6. Inspect the returned [`BacktestReport`](src/quantex/backtester.py:188), including [`BacktestReport.total_return`](src/quantex/backtester.py:227), [`BacktestReport.periods_per_year`](src/quantex/backtester.py:214), [`BacktestReport.plot()`](src/quantex/backtester.py:252), and the printable summary from [`BacktestReport.__str__()`](src/quantex/backtester.py:299).
+5. Run the strategy with [`SimpleBacktester.run()`](src/quantex/backtester/backtester.py:414).
+6. Inspect the returned [`BacktestReport`](src/quantex/backtester/reports.py:4), including [`BacktestReport.total_return`](src/quantex/backtester/reports.py:68), [`BacktestReport.periods_per_year`](src/quantex/backtester/reports.py:58), [`BacktestReport.plot()`](src/quantex/backtester/reports.py:87), and the printable summary from [`BacktestReport.__str__()`](src/quantex/backtester/reports.py:101).
 
 ## Usage
 
@@ -125,22 +125,22 @@ report.plot()
 
 ### 4. Understand what happens during the backtest
 
-When you call [`SimpleBacktester.run()`](src/quantex/backtester.py:414):
+When you call [`SimpleBacktester.run()`](src/quantex/backtester/backtester.py:414):
 
-- the backtester deep-copies your strategy in [`SimpleBacktester.__init__()`](src/quantex/backtester.py:380)
-- starting cash is split evenly across all attached symbols in [`SimpleBacktester.run()`](src/quantex/backtester.py:439)
+- the backtester deep-copies your strategy in [`SimpleBacktester.__init__()`](src/quantex/backtester/backtester.py:26)
+- starting cash is split evenly across all attached symbols in [`SimpleBacktester.run()`](src/quantex/backtester/backtester.py:439)
 - each data source advances one bar at a time by updating [`DataSource.current_index`](src/quantex/datasource.py:62)
-- each symbol's broker processes pending orders through [`Broker._iterate()`](src/quantex/broker.py:483)
+- each symbol's broker processes pending orders through [`Broker._iterate()`](src/quantex/broker/broker.py:483)
 - market orders execute at the current bar's open price through [`DataSource.COpen`](src/quantex/datasource.py:145)
-- equity is tracked into the final [`BacktestReport.PnlRecord`](src/quantex/backtester.py:205)
+- equity is tracked into the final [`BacktestReport.PnlRecord`](src/quantex/backtester/reports.py:52)
 
 ### 5. Understand order sizing
 
 Order sizing in Quantex is simple but important:
 
-- [`Broker.buy()`](src/quantex/broker.py:159) treats `quantity` as a fraction of available cash unless you pass `amount`
-- [`Broker.sell()`](src/quantex/broker.py:235) uses the same sizing calculation and can open or increase a short position
-- [`Broker.close()`](src/quantex/broker.py:307) places a market order that offsets the current position
+- [`Broker.buy()`](src/quantex/broker/broker.py:159) treats `quantity` as a fraction of available cash unless you pass `amount`
+- [`Broker.sell()`](src/quantex/broker/broker.py:235) uses the same sizing calculation and can open or increase a short position
+- [`Broker.close()`](src/quantex/broker/broker.py:307) places a market order that offsets the current position
 
 Because of this design, `buy(0.5)` means “use roughly half of the broker cash for this symbol”, not “buy half a share”.
 
@@ -194,20 +194,20 @@ class MacdTrendStrategy(Strategy):
 
 ### Broker and orders
 
-Each call to [`Strategy.add_data()`](src/quantex/strategy.py:98) also creates a [`Broker`](src/quantex/broker.py:113) for that symbol.
+Each call to [`Strategy.add_data()`](src/quantex/strategy.py:98) also creates a [`Broker`](src/quantex/broker/broker.py:113) for that symbol.
 
 Supported order behavior in the current codebase:
 
-- market orders and limit orders via [`OrderType`](src/quantex/broker.py:24)
-- pending, active, and complete order states via [`OrderStatus`](src/quantex/broker.py:37)
-- optional stop-loss and take-profit triggers stored on [`Order`](src/quantex/broker.py:52)
-- percentage or cash commissions via [`CommissionType`](src/quantex/enums.py:4)
+- market orders and limit orders via [`OrderType`](src/quantex/broker/types.py:4)
+- pending, active, and complete order states via [`OrderStatus`](src/quantex/broker/types.py:16)
+- optional stop-loss and take-profit triggers stored on [`Order`](src/quantex/broker/broker.py:52)
+- percentage or cash commissions via [`CommissionType`](src/quantex/broker/types.py:28)
 
 ## Optimization
 
-[`SimpleBacktester.optimize()`](src/quantex/backtester.py:485) runs a grid search over every parameter combination you provide.
+[`SimpleBacktester.optimize()`](src/quantex/backtester/backtester.py:485) runs a grid search over every parameter combination you provide.
 
-[`SimpleBacktester.optimize_parallel()`](src/quantex/backtester.py:659) does the same work in multiple processes, then re-runs the best parameter set locally to produce a full [`BacktestReport`](src/quantex/backtester.py:188).
+[`SimpleBacktester.optimize_parallel()`](src/quantex/backtester/backtester.py:659) does the same work in multiple processes, then re-runs the best parameter set locally to produce a full [`BacktestReport`](src/quantex/backtester/reports.py:4).
 
 Minimal example:
 
@@ -227,6 +227,64 @@ print(best_report)
 print(results.head())
 ```
 
+### Train/Validate/Test Optimization
+
+[`SimpleBacktester.optimize_with_split()`](src/quantex/backtester/backtester.py:564) performs grid search with ML-style train/validate/test data splits to help detect overfitting.
+
+```python
+result = backtester.optimize_with_split(
+    {"fast_period": [5, 10, 15], "slow_period": [20, 30, 50]},
+    train_ratio=0.6,
+    validate_ratio=0.2,
+    test_ratio=0.2,
+    selection_criterion="validate",  # Select best params based on validate performance
+)
+
+print(f"Best params: {result.best_params}")
+print(f"Train Sharpe: {result.train_metrics['sharpe']}")
+print(f"Validate Sharpe: {result.validate_metrics['sharpe']}")
+print(f"Test Sharpe: {result.test_metrics['sharpe']}")
+```
+
+### Gradient Descent Optimization
+
+[`SimpleBacktester.optimize_gradient_descent()`](src/quantex/backtester/backtester.py:852) uses gradient descent for continuous parameter optimization, supporting momentum, learning rate schedules, and integer parameter handling.
+
+```python
+result = backtester.optimize_gradient_descent(
+    param_init={"fast_period": 10.0, "slow_period": 30.0},
+    param_bounds={
+        "fast_period": (2.0, 50.0),
+        "slow_period": (10.0, 100.0)
+    },
+    learning_rate=0.01,
+    iterations=100,
+    momentum=0.9,
+    integer_params={"fast_period", "slow_period"},
+)
+
+print(f"Optimized params: {result.best_params}")
+print(result.train_report)
+```
+
+### Monte Carlo Simulation
+
+[`SimpleBacktester.monte_carlo()`](src/quantex/backtester/backtester.py:1183) runs Monte Carlo simulations to test strategy robustness through two modes:
+
+- **Trade Order Randomization** ([`MonteCarloMode.TRADE_ORDER`](src/quantex/backtester/montecarlo.py:25)): Shuffles the sequence of trade execution while keeping the same trades
+- **Price Path Resampling** ([`MonteCarloMode.PRICE_PATH`](src/quantex/backtester/montecarlo.py:27)): Creates synthetic market scenarios from historical returns
+
+```python
+result = backtester.monte_carlo(
+    simulations=500,
+    mode="both",  # Run both trade order and price path simulations
+    seed=42,
+)
+
+print(result)  # Print summary statistics (percentiles, confidence intervals)
+result.plot()  # Show spaghetti plot of equity curves
+```
+
 ## Documentation
 
 Project documentation is built with MkDocs. The main docs entry point is [`docs/index.md`](docs/index.md), and usage guides live under [`docs/usage/`](docs/usage/).

{quantex-0.4.0 → quantex-0.4.2}/README.md

@@ -6,9 +6,9 @@ It gives you a small set of building blocks:
 
 - [`Strategy`](src/quantex/strategy.py:9) for your trading rules
 - [`DataSource`](src/quantex/datasource.py:6) plus [`CSVDataSource`](src/quantex/datasource.py:194) and [`ParquetDataSource`](src/quantex/datasource.py:228) for OHLCV market data
-- [`Broker`](src/quantex/broker.py:113) objects, created automatically per symbol, for order placement and position state
-- [`SimpleBacktester`](src/quantex/backtester.py:356) for simulation and parameter search
-- [`BacktestReport`](src/quantex/backtester.py:188) for results, equity history, and summary statistics
+- [`Broker`](src/quantex/broker/broker.py:113) objects, created automatically per symbol, for order placement and position state
+- [`SimpleBacktester`](src/quantex/backtester/backtester.py:26) for simulation and parameter search
+- [`BacktestReport`](src/quantex/backtester/reports.py:4) for results, equity history, and summary statistics
 
 The project is intentionally small. It does not try to be a full research platform, portfolio database, or live-trading engine. Instead, it focuses on a straightforward workflow: load historical bars, define strategy logic, simulate orders, and inspect the results.
 
@@ -28,8 +28,8 @@ At runtime, a typical Quantex workflow looks like this:
 2. In [`Strategy.init()`](src/quantex/strategy.py:52), attach one or more data sources with [`Strategy.add_data()`](src/quantex/strategy.py:98).
 3. Still in [`Strategy.init()`](src/quantex/strategy.py:52), build indicator arrays with the built-in indicator catalog on `self.ta` or the package-level [`indicators`](src/quantex/indicators.py), then register them with [`Strategy.Indicator()`](src/quantex/strategy.py:126).
 4. In [`Strategy.next()`](src/quantex/strategy.py:71), read the current bar through properties such as [`DataSource.COpen`](src/quantex/datasource.py:145) and [`DataSource.CClose`](src/quantex/datasource.py:175), then place orders through the broker stored in [`Strategy.positions`](src/quantex/strategy.py:47).
-5. Run the strategy with [`SimpleBacktester.run()`](src/quantex/backtester.py:414).
-6. Inspect the returned [`BacktestReport`](src/quantex/backtester.py:188), including [`BacktestReport.total_return`](src/quantex/backtester.py:227), [`BacktestReport.periods_per_year`](src/quantex/backtester.py:214), [`BacktestReport.plot()`](src/quantex/backtester.py:252), and the printable summary from [`BacktestReport.__str__()`](src/quantex/backtester.py:299).
+5. Run the strategy with [`SimpleBacktester.run()`](src/quantex/backtester/backtester.py:414).
+6. Inspect the returned [`BacktestReport`](src/quantex/backtester/reports.py:4), including [`BacktestReport.total_return`](src/quantex/backtester/reports.py:68), [`BacktestReport.periods_per_year`](src/quantex/backtester/reports.py:58), [`BacktestReport.plot()`](src/quantex/backtester/reports.py:87), and the printable summary from [`BacktestReport.__str__()`](src/quantex/backtester/reports.py:101).
 
 ## Usage
 
@@ -105,22 +105,22 @@ report.plot()
 
 ### 4. Understand what happens during the backtest
 
-When you call [`SimpleBacktester.run()`](src/quantex/backtester.py:414):
+When you call [`SimpleBacktester.run()`](src/quantex/backtester/backtester.py:414):
 
-- the backtester deep-copies your strategy in [`SimpleBacktester.__init__()`](src/quantex/backtester.py:380)
-- starting cash is split evenly across all attached symbols in [`SimpleBacktester.run()`](src/quantex/backtester.py:439)
+- the backtester deep-copies your strategy in [`SimpleBacktester.__init__()`](src/quantex/backtester/backtester.py:26)
+- starting cash is split evenly across all attached symbols in [`SimpleBacktester.run()`](src/quantex/backtester/backtester.py:439)
 - each data source advances one bar at a time by updating [`DataSource.current_index`](src/quantex/datasource.py:62)
-- each symbol's broker processes pending orders through [`Broker._iterate()`](src/quantex/broker.py:483)
+- each symbol's broker processes pending orders through [`Broker._iterate()`](src/quantex/broker/broker.py:483)
 - market orders execute at the current bar's open price through [`DataSource.COpen`](src/quantex/datasource.py:145)
-- equity is tracked into the final [`BacktestReport.PnlRecord`](src/quantex/backtester.py:205)
+- equity is tracked into the final [`BacktestReport.PnlRecord`](src/quantex/backtester/reports.py:52)
 
 ### 5. Understand order sizing
 
 Order sizing in Quantex is simple but important:
 
-- [`Broker.buy()`](src/quantex/broker.py:159) treats `quantity` as a fraction of available cash unless you pass `amount`
-- [`Broker.sell()`](src/quantex/broker.py:235) uses the same sizing calculation and can open or increase a short position
-- [`Broker.close()`](src/quantex/broker.py:307) places a market order that offsets the current position
+- [`Broker.buy()`](src/quantex/broker/broker.py:159) treats `quantity` as a fraction of available cash unless you pass `amount`
+- [`Broker.sell()`](src/quantex/broker/broker.py:235) uses the same sizing calculation and can open or increase a short position
+- [`Broker.close()`](src/quantex/broker/broker.py:307) places a market order that offsets the current position
 
 Because of this design, `buy(0.5)` means “use roughly half of the broker cash for this symbol”, not “buy half a share”.
 
@@ -174,20 +174,20 @@ class MacdTrendStrategy(Strategy):
 
 ### Broker and orders
 
-Each call to [`Strategy.add_data()`](src/quantex/strategy.py:98) also creates a [`Broker`](src/quantex/broker.py:113) for that symbol.
+Each call to [`Strategy.add_data()`](src/quantex/strategy.py:98) also creates a [`Broker`](src/quantex/broker/broker.py:113) for that symbol.
 
 Supported order behavior in the current codebase:
 
-- market orders and limit orders via [`OrderType`](src/quantex/broker.py:24)
-- pending, active, and complete order states via [`OrderStatus`](src/quantex/broker.py:37)
-- optional stop-loss and take-profit triggers stored on [`Order`](src/quantex/broker.py:52)
-- percentage or cash commissions via [`CommissionType`](src/quantex/enums.py:4)
+- market orders and limit orders via [`OrderType`](src/quantex/broker/types.py:4)
+- pending, active, and complete order states via [`OrderStatus`](src/quantex/broker/types.py:16)
+- optional stop-loss and take-profit triggers stored on [`Order`](src/quantex/broker/broker.py:52)
+- percentage or cash commissions via [`CommissionType`](src/quantex/broker/types.py:28)
 
 ## Optimization
 
-[`SimpleBacktester.optimize()`](src/quantex/backtester.py:485) runs a grid search over every parameter combination you provide.
+[`SimpleBacktester.optimize()`](src/quantex/backtester/backtester.py:485) runs a grid search over every parameter combination you provide.
 
-[`SimpleBacktester.optimize_parallel()`](src/quantex/backtester.py:659) does the same work in multiple processes, then re-runs the best parameter set locally to produce a full [`BacktestReport`](src/quantex/backtester.py:188).
+[`SimpleBacktester.optimize_parallel()`](src/quantex/backtester/backtester.py:659) does the same work in multiple processes, then re-runs the best parameter set locally to produce a full [`BacktestReport`](src/quantex/backtester/reports.py:4).
 
 Minimal example:
 
@@ -207,6 +207,64 @@ print(best_report)
 print(results.head())
 ```
 
+### Train/Validate/Test Optimization
+
+[`SimpleBacktester.optimize_with_split()`](src/quantex/backtester/backtester.py:564) performs grid search with ML-style train/validate/test data splits to help detect overfitting.
+
+```python
+result = backtester.optimize_with_split(
+    {"fast_period": [5, 10, 15], "slow_period": [20, 30, 50]},
+    train_ratio=0.6,
+    validate_ratio=0.2,
+    test_ratio=0.2,
+    selection_criterion="validate",  # Select best params based on validate performance
+)
+
+print(f"Best params: {result.best_params}")
+print(f"Train Sharpe: {result.train_metrics['sharpe']}")
+print(f"Validate Sharpe: {result.validate_metrics['sharpe']}")
+print(f"Test Sharpe: {result.test_metrics['sharpe']}")
+```
+
+### Gradient Descent Optimization
+
+[`SimpleBacktester.optimize_gradient_descent()`](src/quantex/backtester/backtester.py:852) uses gradient descent for continuous parameter optimization, supporting momentum, learning rate schedules, and integer parameter handling.
+
+```python
+result = backtester.optimize_gradient_descent(
+    param_init={"fast_period": 10.0, "slow_period": 30.0},
+    param_bounds={
+        "fast_period": (2.0, 50.0),
+        "slow_period": (10.0, 100.0)
+    },
+    learning_rate=0.01,
+    iterations=100,
+    momentum=0.9,
+    integer_params={"fast_period", "slow_period"},
+)
+
+print(f"Optimized params: {result.best_params}")
+print(result.train_report)
+```
+
+### Monte Carlo Simulation
+
+[`SimpleBacktester.monte_carlo()`](src/quantex/backtester/backtester.py:1183) runs Monte Carlo simulations to test strategy robustness through two modes:
+
+- **Trade Order Randomization** ([`MonteCarloMode.TRADE_ORDER`](src/quantex/backtester/montecarlo.py:25)): Shuffles the sequence of trade execution while keeping the same trades
+- **Price Path Resampling** ([`MonteCarloMode.PRICE_PATH`](src/quantex/backtester/montecarlo.py:27)): Creates synthetic market scenarios from historical returns
+
+```python
+result = backtester.monte_carlo(
+    simulations=500,
+    mode="both",  # Run both trade order and price path simulations
+    seed=42,
+)
+
+print(result)  # Print summary statistics (percentiles, confidence intervals)
+result.plot()  # Show spaghetti plot of equity curves
+```
+
 ## Documentation
 
 Project documentation is built with MkDocs. The main docs entry point is [`docs/index.md`](docs/index.md), and usage guides live under [`docs/usage/`](docs/usage/).

{quantex-0.4.0 → quantex-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quantex"
-version = "0.4.0"
+version = "0.4.2"
 description = "A simple quant strategy creation and backtesting package."
 authors = [
     {name = "Daniel Green",email = "dangreen07@outlook.com"}

{quantex-0.4.0 → quantex-0.4.2}/src/quantex/backtester/montecarlo.py

@@ -112,10 +112,23 @@ class MonteCarloResult:
         
         fig, ax = plt.subplots(figsize=figsize)
         
+        # Plot using a numeric simulation step axis to avoid date conversion
+        # artifacts when equity curves share the same time index.
+        if not self.equity_curves:
+            ax.set_xlabel("Step")
+            ax.set_ylabel("Portfolio Value")
+            ax.set_title(f"Monte Carlo Simulation Results ({self.simulations} simulations)")
+            ax.grid(alpha=0.3)
+            plt.tight_layout()
+            plt.show()
+            return
+
+        step_index = np.arange(len(self.equity_curves[0]), dtype=np.float64)
+        
         # Plot all simulation curves with low alpha (transparency)
         # This makes the average path appear lightest due to overlap
         for curve in self.equity_curves:
-            x_vals = np.asarray(curve.index, dtype=np.float64)
+            x_vals = np.arange(len(curve), dtype=np.float64)
             y_vals = np.asarray(curve.values, dtype=np.float64)
             ax.plot(x_vals, y_vals, color="steelblue", alpha=0.1, linewidth=0.5)
         
@@ -127,18 +140,18 @@ class MonteCarloResult:
             median_curve = aligned.median(axis=1)
             
             # Plot mean curve (thicker, lighter)
-            x_mean = np.asarray(mean_curve.index, dtype=np.float64)
+            x_mean = np.arange(len(mean_curve), dtype=np.float64)
             y_mean = np.asarray(mean_curve.values, dtype=np.float64)
             ax.plot(x_mean, y_mean, color="darkblue", alpha=0.8, linewidth=2, label="Mean")
             
             # Plot median curve
-            x_med = np.asarray(median_curve.index, dtype=np.float64)
+            x_med = np.arange(len(median_curve), dtype=np.float64)
             y_med = np.asarray(median_curve.values, dtype=np.float64)
             ax.plot(x_med, y_med, color="navy", alpha=0.6, linewidth=1.5, linestyle="--", label="Median")
         
         # Show original equity curve if requested
         if show_original and self.original_equity is not None:
-            x_orig = np.asarray(self.original_equity.index, dtype=np.float64)
+            x_orig = np.arange(len(self.original_equity), dtype=np.float64)
             y_orig = np.asarray(self.original_equity.values, dtype=np.float64)
             ax.plot(x_orig, y_orig, color="red", alpha=0.9, linewidth=2, label="Original Backtest")
         
@@ -147,16 +160,19 @@ class MonteCarloResult:
             aligned = pd.concat(self.equity_curves, axis=1)
             p5 = aligned.quantile(0.05, axis=1)
             p95 = aligned.quantile(0.95, axis=1)
-            x_p5 = np.asarray(p5.index, dtype=np.float64)
+            x_p5 = np.arange(len(p5), dtype=np.float64)
             y_p5 = np.asarray(p5.values, dtype=np.float64)
             y_p95 = np.asarray(p95.values, dtype=np.float64)
             ax.fill_between(x_p5, y_p5, y_p95, alpha=0.2, color="steelblue", label="5th-95th Percentile")
         
-        ax.set_xlabel("Date")
+        ax.set_xlabel("Step")
         ax.set_ylabel("Portfolio Value")
         ax.set_title(f"Monte Carlo Simulation Results ({self.simulations} simulations)")
         ax.legend(loc="best")
         ax.grid(alpha=0.3)
+
+        # Match the more compact spaghetti-plot look by tightening x-limits.
+        ax.set_xlim(step_index[0], step_index[-1])
         
         plt.tight_layout()
         plt.show()
@@ -282,32 +298,78 @@ def _run_price_path_simulation(
     synthetic_sources = {}
     
     for symbol, source in data_sources.items():
-        close_prices = source.data['Close'].values
-        
-        # Calculate log returns
+        close_prices = np.asarray(source.data["Close"].values, dtype=np.float64)
+        if len(close_prices) < 2:
+            synthetic_sources[symbol] = DataSource(source.data.copy())
+            continue
+
+        # Use a block-bootstrap on log returns to preserve local serial dependence
+        # and then re-price the path using a geometric Brownian motion style
+        # reconstruction with the sampled return distribution.
         log_returns = np.diff(np.log(close_prices))
-        
-        # Resample with replacement
         n_samples = len(log_returns)
-        resampled_indices = np.random.randint(0, n_samples, size=n_samples)
-        resampled_returns = log_returns[resampled_indices]
-        
-        # Reconstruct price path starting from initial price
-        synthetic_prices = np.zeros(n_samples + 1)
-        synthetic_prices[0] = close_prices[0]
-        synthetic_prices[1:] = close_prices[0] * np.exp(np.cumsum(resampled_returns))
-        
-        # Create synthetic OHLCV data
-        # Use the same pattern but with resampled close prices
-        synthetic_df = source.data.copy()
-        synthetic_df['Close'] = synthetic_prices
-        
-        # Adjust Open, High, Low based on close (simple approximation)
-        # This is a simplification - real implementation would need proper OHLC generation
-        synthetic_df['Open'] = synthetic_prices * (1 + np.random.uniform(-0.001, 0.001, n_samples + 1))
-        synthetic_df['High'] = np.maximum(synthetic_prices, synthetic_df['Open']) * (1 + np.random.uniform(0, 0.002, n_samples + 1))
-        synthetic_df['Low'] = np.minimum(synthetic_prices, synthetic_df['Open']) * (1 - np.random.uniform(0, 0.002, n_samples + 1))
-        
+        block_size = max(2, min(10, int(np.sqrt(n_samples))))
+        synthetic_log_returns = []
+
+        while len(synthetic_log_returns) < n_samples:
+            start = int(np.random.randint(0, n_samples))
+            block = log_returns[start : start + block_size]
+            if len(block) < block_size:
+                wrap = block_size - len(block)
+                block = np.concatenate((block, log_returns[:wrap]))
+            synthetic_log_returns.extend(block.tolist())
+
+        synthetic_log_returns = np.asarray(synthetic_log_returns[:n_samples], dtype=np.float64)
+
+        # Keep the simulated path realistic by matching the original return
+        # center and volatility rather than letting the bootstrap drift too far.
+        original_mean = float(np.mean(log_returns))
+        original_std = float(np.std(log_returns))
+        synthetic_mean = float(np.mean(synthetic_log_returns))
+        synthetic_std = float(np.std(synthetic_log_returns))
+        if synthetic_std > 0 and original_std > 0:
+            synthetic_log_returns = (synthetic_log_returns - synthetic_mean) * (original_std / synthetic_std) + original_mean
+        else:
+            synthetic_log_returns = synthetic_log_returns - synthetic_mean + original_mean
+
+        synthetic_close = np.empty(n_samples + 1, dtype=np.float64)
+        synthetic_close[0] = close_prices[0]
+        synthetic_close[1:] = synthetic_close[0] * np.exp(np.cumsum(synthetic_log_returns))
+        synthetic_close = np.maximum(synthetic_close, np.finfo(np.float64).tiny)
+
+        # Derive intraday range from the historical candle shape so OHLC remains coherent.
+        source_df = source.data.copy()
+        if "Open" in source_df.columns:
+            open_close_gap = np.log(np.asarray(source_df["Open"].values, dtype=np.float64) / close_prices)
+            open_close_gap = np.nan_to_num(open_close_gap, nan=0.0, posinf=0.0, neginf=0.0)
+        else:
+            open_close_gap = np.zeros_like(synthetic_close)
+
+        open_noise = np.random.choice(open_close_gap, size=n_samples + 1, replace=True)
+        synthetic_open = synthetic_close * np.exp(open_noise)
+
+        if {"High", "Low"}.issubset(source_df.columns):
+            high_wick = np.log(np.asarray(source_df["High"].values, dtype=np.float64) / np.maximum(close_prices, np.finfo(np.float64).tiny))
+            low_wick = np.log(np.asarray(source_df["Low"].values, dtype=np.float64) / np.maximum(close_prices, np.finfo(np.float64).tiny))
+            high_wick = np.nan_to_num(high_wick, nan=0.0, posinf=0.0, neginf=0.0)
+            low_wick = np.nan_to_num(low_wick, nan=0.0, posinf=0.0, neginf=0.0)
+            synthetic_high = np.maximum(synthetic_open, synthetic_close) * np.exp(np.abs(np.random.choice(high_wick, size=n_samples + 1, replace=True)))
+            synthetic_low = np.minimum(synthetic_open, synthetic_close) * np.exp(-np.abs(np.random.choice(low_wick, size=n_samples + 1, replace=True)))
+        else:
+            synthetic_high = np.maximum(synthetic_open, synthetic_close)
+            synthetic_low = np.minimum(synthetic_open, synthetic_close)
+
+        synthetic_df = source_df
+        synthetic_df["Close"] = synthetic_close
+        synthetic_df["Open"] = synthetic_open
+        synthetic_df["High"] = np.maximum.reduce([synthetic_high, synthetic_open, synthetic_close])
+        synthetic_df["Low"] = np.minimum.reduce([synthetic_low, synthetic_open, synthetic_close])
+
+        if "Volume" in synthetic_df.columns:
+            volume = np.asarray(source_df["Volume"].values, dtype=np.float64)
+            if len(volume) == n_samples + 1:
+                synthetic_df["Volume"] = np.maximum(0.0, np.random.choice(volume, size=n_samples + 1, replace=True))
+
         synthetic_sources[symbol] = DataSource(synthetic_df)
     
     # Update strategy with synthetic data sources