Upload 29 files

.gitattributes

@@ -1,35 +1,3 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+images/filled_ticks_4panel.png filter=lfs diff=lfs merge=lfs -text
+images/raw_ticks_4panel.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+.venv
+.env

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ContinualQuasars
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

Python/mt5_filled_ticks.py

@@ -0,0 +1,224 @@
+"""
+Script 2 — Gap-Filled Microsecond Bid-Ask Unit Data Visualization
+Fetches the SAME XAUUSDc data as Script 1, then fills every missing
+price level between consecutive data points so that the Y-distribution
+histogram reflects the full path traversed, not just the endpoints.
+
+Output: 4-panel figure identical in layout to Script 1 but built on the
+gap-filled DataFrame.
+
+0.01 unit = $0.01 XAU price change.
+The 'c' suffix in XAUUSDc is an Exness broker account-type indicator
+(standard cent live account), not related to XAU pricing.
+"""
+
+import MetaTrader5 as mt5
+import pandas as pd
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')  # Headless backend — no GUI window
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+from datetime import datetime, timezone
+
+# ──────────────────────────────────────────────
+# 1. Connect to MT5
+# ──────────────────────────────────────────────
+if not mt5.initialize():
+    print(f"MT5 initialize() failed, error code = {mt5.last_error()}")
+    quit()
+
+# ──────────────────────────────────────────────
+# 2. Define time range (Feb 12 2026, full day UTC)
+# ──────────────────────────────────────────────
+utc_from = datetime(2026, 2, 12, 0, 0, 0, tzinfo=timezone.utc)
+utc_to   = datetime(2026, 2, 12, 23, 59, 59, tzinfo=timezone.utc)
+
+SYMBOL    = "XAUUSDc"
+UNIT_SIZE = 0.01  # the binsize (0.01 unit = $0.01 XAU price change)
+
+# ──────────────────────────────────────────────
+# 3. Fetch data from MT5 (same query as Script 1)
+# ──────────────────────────────────────────────
+ticks = mt5.copy_ticks_range(SYMBOL, utc_from, utc_to, mt5.COPY_TICKS_ALL)
+
+if ticks is None or len(ticks) == 0:
+    print(f"No data retrieved for {SYMBOL}. Error: {mt5.last_error()}")
+    mt5.shutdown()
+    quit()
+
+df = pd.DataFrame(ticks)
+df['datetime'] = pd.to_datetime(df['time_msc'], unit='ms', utc=True)
+
+print(f"Fetched {len(df):,} raw data points for {SYMBOL}")
+mt5.shutdown()
+
+# Save raw unit CSV (same data as Script 1)
+csv_raw = "raw_ticks_XAUUSDc_20260212.csv"  # filename kept for compatibility
+df[['datetime', 'bid', 'ask', 'last', 'volume', 'flags']].to_csv(csv_raw, index=False)
+print(f"Saved CSV → {csv_raw}  ({len(df):,} rows)")
+
+# ──────────────────────────────────────────────
+# 4. Vectorised gap-filling function
+# ──────────────────────────────────────────────
+def fill_gaps(prices: np.ndarray, timestamps_ns: np.ndarray, unit_size: float):
+    """
+    Vectorised gap-fill: for every consecutive pair (A → B),
+    insert intermediate price levels at every unit_size step.
+    timestamps_ns should be int64 nanoseconds.
+    """
+    diff_units = np.round(np.diff(prices) / unit_size).astype(np.int64)
+    counts = np.abs(diff_units)
+    # Last point gets a count of 1 (just itself)
+    counts = np.append(counts, 1)
+
+    total = int(np.sum(counts))
+    indices = np.repeat(np.arange(len(prices)), counts)
+
+    # Offset within each segment
+    cum = np.cumsum(counts)
+    starts = np.empty_like(cum)
+    starts[0] = 0
+    starts[1:] = cum[:-1]
+    offsets = np.arange(total) - np.repeat(starts, counts)
+
+    # Direction per segment
+    directions = np.zeros(len(prices), dtype=np.float64)
+    directions[:-1] = np.sign(diff_units)
+
+    # Time step per segment
+    dt = np.zeros(len(prices), dtype=np.float64)
+    dt[:-1] = np.diff(timestamps_ns).astype(np.float64)
+    steps = dt / np.where(counts > 0, counts, 1)
+
+    filled_prices = prices[indices] + offsets * directions[indices] * unit_size
+    filled_ts = timestamps_ns[indices].astype(np.float64) + offsets * steps[indices]
+
+    return np.round(filled_prices, 2), filled_ts.astype(np.int64)
+
+
+# ──────────────────────────────────────────────
+# 5. Apply gap-filling to bid and ask separately
+# ──────────────────────────────────────────────
+ts_ns = df['datetime'].values.astype('datetime64[ns]').astype(np.int64)
+
+print("Gap-filling bid...")
+bid_prices_filled, bid_ts_filled = fill_gaps(df['bid'].values, ts_ns, UNIT_SIZE)
+print("Gap-filling ask...")
+ask_prices_filled, ask_ts_filled = fill_gaps(df['ask'].values, ts_ns, UNIT_SIZE)
+
+print(f"Bid: {len(df):,} raw → {len(bid_prices_filled):,} filled rows")
+print(f"Ask: {len(df):,} raw → {len(ask_prices_filled):,} filled rows")
+
+# Save gap-filled CSVs
+bid_filled_df = pd.DataFrame({
+    'datetime': pd.to_datetime(bid_ts_filled, unit='ns', utc=True),
+    'bid_filled': bid_prices_filled,
+})
+bid_csv = "filled_bid_XAUUSDc_20260212.csv"
+bid_filled_df.to_csv(bid_csv, index=False)
+print(f"Saved CSV → {bid_csv}  ({len(bid_filled_df):,} rows)")
+
+ask_filled_df = pd.DataFrame({
+    'datetime': pd.to_datetime(ask_ts_filled, unit='ns', utc=True),
+    'ask_filled': ask_prices_filled,
+})
+ask_csv = "filled_ask_XAUUSDc_20260212.csv"
+ask_filled_df.to_csv(ask_csv, index=False)
+print(f"Saved CSV → {ask_csv}  ({len(ask_filled_df):,} rows)")
+
+# Convert ns timestamps to matplotlib date floats
+# matplotlib dates = days since 0001-01-01; Unix epoch = day 719163
+_UNIX_EPOCH_MPLDATE = 719163.0
+bid_times = bid_ts_filled / 1e9 / 86400.0 + _UNIX_EPOCH_MPLDATE
+ask_times = ask_ts_filled / 1e9 / 86400.0 + _UNIX_EPOCH_MPLDATE
+
+# ──────────────────────────────────────────────
+# 6. Build histogram bins (1 bin = 0.01 unit)
+# ──────────────────────────────────────────────
+overall_min = min(bid_prices_filled.min(), ask_prices_filled.min())
+overall_max = max(bid_prices_filled.max(), ask_prices_filled.max())
+
+bin_lo = np.floor(overall_min / UNIT_SIZE) * UNIT_SIZE - UNIT_SIZE
+bin_hi = np.ceil(overall_max / UNIT_SIZE) * UNIT_SIZE + UNIT_SIZE
+bins = np.round(np.arange(bin_lo, bin_hi + UNIT_SIZE, UNIT_SIZE), 2)
+
+print("Plotting...")
+
+# ──────────────────────────────────────────────
+# 7. Plot 4-panel figure
+# ──────────────────────────────────────────────
+fig, axes = plt.subplots(
+    2, 2,
+    figsize=(20, 12),
+    gridspec_kw={'width_ratios': [1, 4]},
+    sharey='row',
+)
+fig.suptitle(
+    f'{SYMBOL} — Gap-Filled Unit Data (Path-Weighted)  |  {utc_from.strftime("%Y-%m-%d")}',
+    fontsize=16, fontweight='bold',
+)
+
+# Colors — 100% blue and 100% red per IDEA.md
+BID_COLOR = '#0000FF'
+ASK_COLOR = '#FF0000'
+
+# ── Row 0: BID ─────────────────────────────
+ax_hist_bid = axes[0, 0]
+ax_line_bid = axes[0, 1]
+
+ax_hist_bid.hist(
+    bid_prices_filled, bins=bins, orientation='horizontal',
+    color=BID_COLOR, alpha=1.0, edgecolor='white', linewidth=0.3,
+)
+ax_hist_bid.set_xlabel('Count (path-weighted)', fontsize=10)
+ax_hist_bid.set_ylabel('Bid Price', fontsize=10)
+ax_hist_bid.set_title('Bid Y-Distribution — Gap-Filled (0.01-unit bins)', fontsize=12)
+# histogram grows left-to-right (starts from 0)
+
+# Line only — no markers for 4M+ points, rasterized
+ax_line_bid.plot(
+    bid_times, bid_prices_filled,
+    color=BID_COLOR, linewidth=0.5, alpha=1.0,
+    rasterized=True,
+)
+ax_line_bid.xaxis_date()
+ax_line_bid.set_title('Bid Price — Gap-Filled (Time Series)', fontsize=12)
+ax_line_bid.set_xlabel('Time (UTC)', fontsize=10)
+ax_line_bid.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
+ax_line_bid.xaxis.set_major_locator(mdates.HourLocator(interval=2))
+plt.setp(ax_line_bid.xaxis.get_majorticklabels(), rotation=45, ha='right')
+ax_line_bid.grid(True, alpha=0.3)
+
+# ── Row 1: ASK ─────────────────────────────
+ax_hist_ask = axes[1, 0]
+ax_line_ask = axes[1, 1]
+
+ax_hist_ask.hist(
+    ask_prices_filled, bins=bins, orientation='horizontal',
+    color=ASK_COLOR, alpha=1.0, edgecolor='white', linewidth=0.3,
+)
+ax_hist_ask.set_xlabel('Count (path-weighted)', fontsize=10)
+ax_hist_ask.set_ylabel('Ask Price', fontsize=10)
+ax_hist_ask.set_title('Ask Y-Distribution — Gap-Filled (0.01-unit bins)', fontsize=12)
+# histogram grows left-to-right (starts from 0)
+
+ax_line_ask.plot(
+    ask_times, ask_prices_filled,
+    color=ASK_COLOR, linewidth=0.5, alpha=1.0,
+    rasterized=True,
+)
+ax_line_ask.xaxis_date()
+ax_line_ask.set_title('Ask Price — Gap-Filled (Time Series)', fontsize=12)
+ax_line_ask.set_xlabel('Time (UTC)', fontsize=10)
+ax_line_ask.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
+ax_line_ask.xaxis.set_major_locator(mdates.HourLocator(interval=2))
+plt.setp(ax_line_ask.xaxis.get_majorticklabels(), rotation=45, ha='right')
+ax_line_ask.grid(True, alpha=0.3)
+
+# ── Final layout ───────────────────────────
+plt.tight_layout(rect=[0, 0, 1, 0.95])
+
+output_path = "filled_ticks_4panel.png"
+fig.savefig(output_path, dpi=150, bbox_inches='tight')
+print(f"Saved → {output_path}")

Python/mt5_raw_ticks.py

@@ -0,0 +1,166 @@
+"""
+Script 1 — Raw Microsecond Bid-Ask Unit Data Visualization
+Fetches XAUUSDc data from MetaTrader 5 for February 12, 2026 (full day),
+and produces a 4-panel figure:
+  Top-left:    Bid Y-distribution histogram  (blue, 0.01-unit bins)
+  Top-right:   Bid line chart with dot markers (blue)
+  Bottom-left: Ask Y-distribution histogram  (red, 0.01-unit bins)
+  Bottom-right:Ask line chart with dot markers (red)
+
+0.01 unit = $0.01 XAU price change.
+The 'c' suffix in XAUUSDc is an Exness broker account-type indicator
+(standard cent live account), not related to XAU pricing.
+"""
+
+import MetaTrader5 as mt5
+import pandas as pd
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')  # Headless backend — no GUI window
+import matplotlib.pyplot as plt
+import matplotlib.dates as mdates
+from datetime import datetime, timezone
+
+# ──────────────────────────────────────────────
+# 1. Connect to MT5
+# ──────────────────────────────────────────────
+if not mt5.initialize():
+    print(f"MT5 initialize() failed, error code = {mt5.last_error()}")
+    quit()
+
+# ──────────────────────────────────────────────
+# 2. Define time range (Feb 12 2026, full day UTC)
+# ──────────────────────────────────────────────
+utc_from = datetime(2026, 2, 12, 0, 0, 0, tzinfo=timezone.utc)
+utc_to   = datetime(2026, 2, 12, 23, 59, 59, tzinfo=timezone.utc)
+
+SYMBOL = "XAUUSDc"
+UNIT_SIZE = 0.01  # the binsize (0.01 unit = $0.01 XAU price change)
+
+# ──────────────────────────────────────────────
+# 3. Fetch data from MT5
+# ──────────────────────────────────────────────
+ticks = mt5.copy_ticks_range(SYMBOL, utc_from, utc_to, mt5.COPY_TICKS_ALL)
+
+if ticks is None or len(ticks) == 0:
+    print(f"No data retrieved for {SYMBOL}. Error: {mt5.last_error()}")
+    mt5.shutdown()
+    quit()
+
+df = pd.DataFrame(ticks)
+# MT5 returns time in seconds since epoch; time_msc is milliseconds
+df['datetime'] = pd.to_datetime(df['time_msc'], unit='ms', utc=True)
+
+print(f"Fetched {len(df):,} data points for {SYMBOL}")
+print(f"Time range: {df['datetime'].iloc[0]}  →  {df['datetime'].iloc[-1]}")
+print(f"Bid range : {df['bid'].min():.2f} – {df['bid'].max():.2f}")
+print(f"Ask range : {df['ask'].min():.2f} – {df['ask'].max():.2f}")
+
+mt5.shutdown()
+
+# ──────────────────────────────────────────────
+# 3b. Save raw unit data to CSV
+# ──────────────────────────────────────────────
+csv_path = "raw_ticks_XAUUSDc_20260212.csv"
+df[['datetime', 'bid', 'ask', 'last', 'volume', 'flags']].to_csv(csv_path, index=False)
+print(f"Saved CSV → {csv_path}  ({len(df):,} rows)")
+
+# ──────────────────────────────────────────────
+# 4. Build histogram bins (1 bin = 0.01 unit)
+# ──────────────────────────────────────────────
+overall_min = min(df['bid'].min(), df['ask'].min())
+overall_max = max(df['bid'].max(), df['ask'].max())
+
+bin_lo = np.floor(overall_min / UNIT_SIZE) * UNIT_SIZE - UNIT_SIZE
+bin_hi = np.ceil(overall_max / UNIT_SIZE) * UNIT_SIZE + UNIT_SIZE
+bins = np.arange(bin_lo, bin_hi + UNIT_SIZE, UNIT_SIZE)
+bins = np.round(bins, 2)
+
+# ──────────────────────────────────────────────
+# 5. Convert datetimes to float (much faster for plotting)
+# ──────────────────────────────────────────────
+bid_times = mdates.date2num(df['datetime'].values)
+ask_times = bid_times  # same timestamps
+
+print("Plotting...")
+
+# ──────────────────────────────────────────────
+# 6. Plot 4-panel figure
+# ──────────────────────────────────────────────
+fig, axes = plt.subplots(
+    2, 2,
+    figsize=(20, 12),
+    gridspec_kw={'width_ratios': [1, 4]},
+    sharey='row',
+)
+fig.suptitle(
+    f'{SYMBOL} — Raw Microsecond Unit Data  |  {utc_from.strftime("%Y-%m-%d")}',
+    fontsize=16, fontweight='bold',
+)
+
+# Colors — 100% blue and 100% red per IDEA.md
+BID_COLOR = '#0000FF'
+ASK_COLOR = '#FF0000'
+
+# ── Row 0: BID ─────────────────────────────
+ax_hist_bid = axes[0, 0]
+ax_line_bid = axes[0, 1]
+
+# Histogram (horizontal)
+ax_hist_bid.hist(
+    df['bid'].values, bins=bins, orientation='horizontal',
+    color=BID_COLOR, alpha=1.0, edgecolor='white', linewidth=0.3,
+)
+ax_hist_bid.set_xlabel('Count', fontsize=10)
+ax_hist_bid.set_ylabel('Bid Price', fontsize=10)
+ax_hist_bid.set_title('Bid Y-Distribution (0.01-unit bins)', fontsize=12)
+# histogram grows left-to-right (starts from 0)
+
+# Line chart — use line only (no markers) for massive data, rasterized
+ax_line_bid.plot(
+    bid_times, df['bid'].values,
+    color=BID_COLOR, linewidth=0.5, alpha=1.0,
+    rasterized=True,
+)
+ax_line_bid.xaxis_date()
+ax_line_bid.set_title('Bid Price (Time Series)', fontsize=12)
+ax_line_bid.set_xlabel('Time (UTC)', fontsize=10)
+ax_line_bid.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
+ax_line_bid.xaxis.set_major_locator(mdates.HourLocator(interval=2))
+plt.setp(ax_line_bid.xaxis.get_majorticklabels(), rotation=45, ha='right')
+ax_line_bid.grid(True, alpha=0.3)
+
+# ── Row 1: ASK ─────────────────────────────
+ax_hist_ask = axes[1, 0]
+ax_line_ask = axes[1, 1]
+
+# Histogram (horizontal)
+ax_hist_ask.hist(
+    df['ask'].values, bins=bins, orientation='horizontal',
+    color=ASK_COLOR, alpha=1.0, edgecolor='white', linewidth=0.3,
+)
+ax_hist_ask.set_xlabel('Count', fontsize=10)
+ax_hist_ask.set_ylabel('Ask Price', fontsize=10)
+ax_hist_ask.set_title('Ask Y-Distribution (0.01-unit bins)', fontsize=12)
+# histogram grows left-to-right (starts from 0)
+
+# Line chart — line only, rasterized
+ax_line_ask.plot(
+    ask_times, df['ask'].values,
+    color=ASK_COLOR, linewidth=0.5, alpha=1.0,
+    rasterized=True,
+)
+ax_line_ask.xaxis_date()
+ax_line_ask.set_title('Ask Price (Time Series)', fontsize=12)
+ax_line_ask.set_xlabel('Time (UTC)', fontsize=10)
+ax_line_ask.xaxis.set_major_formatter(mdates.DateFormatter('%H:%M'))
+ax_line_ask.xaxis.set_major_locator(mdates.HourLocator(interval=2))
+plt.setp(ax_line_ask.xaxis.get_majorticklabels(), rotation=45, ha='right')
+ax_line_ask.grid(True, alpha=0.3)
+
+# ── Final layout ───────────────────────────
+plt.tight_layout(rect=[0, 0, 1, 0.95])
+
+output_path = "raw_ticks_4panel.png"
+fig.savefig(output_path, dpi=150, bbox_inches='tight')
+print(f"Saved → {output_path}")

README.md

@@ -0,0 +1,95 @@
+# What Happens if We Increase or Decrease the Bin Size of Market Profiles (TPO & Volume)?
+
+This applies specifically to the standard or free-tier market profiles available on most charting platforms. Market profiles are typically built on either the **Time Price Opportunity (TPO)** profile or the **Volume Profile (VP)**, whether real or tick-based. Regardless of the type, the underlying calculation is the same: raw data is cleaned through dataframes (xlsx, csv, etc.) and represented through graphs (lines, bars, plots, etc.). A market profile is simply datapoints collapsed into a y-axis distribution, forming a "profile." That is it -- nothing more.
+
+But what actually happens when we increase or decrease the **bin size** (the price-step) of the market profile?
+
+<br><br>
+
+## Collapsing Price Action into a Profile
+
+<table>
+  <tr>
+    <td align="center">
+      <img width="995" height="488" alt="Collapsing price action into a market profile" src="https://github.com/user-attachments/assets/30f8a35e-1060-48c2-8f63-bbda3b989c93" />
+    </td>
+  </tr>
+</table>
+
+In the figure above, we have one MP chart (left) and one line chart (right), both derived from the same dataset. The price action over time (line chart) moves from point **A** to **B**, **C**, and **D**. When we collapse those datapoints (A through D) into a y-axis distribution histogram, a Market Profile chart is formed.
+
+If we use a bin size of **1.000** and the price range spans **3000.000 to 3010.000**, then between those prices we get **10 bins** worth of grouping. Same data, different representation.
+
+<br><br>
+
+## Larger Datasets and Stacking
+
+<table>
+  <tr>
+    <td align="center">
+      <img width="996" height="488" alt="Larger dataset forming a market profile" src="https://github.com/user-attachments/assets/f05cdd33-80a0-47e1-8041-56543ef5d7d5" />
+    </td>
+  </tr>
+</table>
+
+With larger datasets, the principle remains the same. Datapoints collapse and stack to form a y-distribution. The more stacking occurs, the larger the profile becomes. In this example, the lowest profile value is **0** and the largest profile value is **4 stacks**.
+
+<br><br>
+
+## The Effect of Changing Bin Size
+
+<table>
+  <tr>
+    <td align="center">
+      <img width="995" height="484" alt="Market profile with different bin size" src="https://github.com/user-attachments/assets/6637ea25-0abc-40ad-a8a1-b35d2abd89cb" />
+    </td>
+  </tr>
+</table>
+
+The figure above uses the **same dataset** as the previous one, yet the profile looks different. It now has a lowest value of **0** and a largest value of only **2 stacks**. If you are a beginner, this might feel suspicious when experimenting on your preferred charting platform -- but it is completely normal.
+
+The reason is straightforward: **more bins means more price groups for the datapoints to distribute across.** As bin size decreases (more granular bins), each datapoint lands in a more specific price bucket. This spreads the data across more bins, resulting in shorter stacks and a flatter profile. Conversely, increasing the bin size consolidates datapoints into fewer groups, producing taller stacks and a more concentrated profile.
+
+That is the kind of market profile you typically get on free-tier charting and trading platforms.
+
+<br><br>
+
+## An Alternative Approach: Trail-Price Clustering
+
+There is another way to model a market profile. Without going into full detail -- if you are an algorithmic trader or software developer familiar with feature engineering, this will be straightforward. The core idea is to **add data to your original dataframes by clustering trail-prices** (an original concept) to produce a more complete set of datapoints.
+
+<table>
+  <tr>
+    <td align="center">
+      <img width="1006" height="490" alt="Trail-price clustering concept" src="https://github.com/user-attachments/assets/8277ff21-9999-4ac1-b9db-e7c8b99578a3" />
+    </td>
+  </tr>
+</table>
+
+This concept extends well beyond these illustrations. You can fill in missing data in dataframes (for any dataset) by applying a custom formula using your preferred programming language.
+
+<br><br>
+
+<table>
+  <tr>
+    <td align="center">
+      <img width="1066" height="519" alt="Enhanced market profile model" src="https://github.com/user-attachments/assets/e2bcdea8-1944-4c4f-a467-1d8943972512" />
+    </td>
+  </tr>
+</table>
+
+The drawings may be rough, but the point stands. In our case, we model a market profile not based on **TOCHL** (Time, Open, Close, High, Low) or **Volume** (real, tick) but on **mBA** (microsecond raw bid/ask) formation.
+
+<br><br>
+
+## Reference
+
+```bibtex
+@misc{continualquasars2026blog1,
+  title   = {What Happens if We Increase or Decrease the Bin Size of Market Profiles (TPO \& Volume)?},
+  author  = {ContinualQuasars},
+  year    = {2026},
+  url     = {https://github.com/ContinualQuasars/BLOG-1},
+  note    = {What Happens if We Increase or Decrease the Bin Size of Market Profiles (TPO \& Volume)?}
+}
+```

STRUCTURE.md

@@ -0,0 +1,41 @@
+## Project Structure
+
+```text
+mBA-Terminal/
+├── images/
+│   ├── filled_ticks_4panel.png
+│   └── raw_ticks_4panel.png
+├── output/
+│   ├── filled_ask_XAUUSDc_20260212.csv
+│   ├── filled_bid_XAUUSDc_20260212.csv
+│   └── raw_ticks_XAUUSDc_20260212.csv
+├── Python/
+│   ├── mt5_filled_ticks.py
+│   └── mt5_raw_ticks.py
+├── scripts/
+│   └── debug_mt5.py
+├── src/
+│   ├── core/
+│   │   ├── data_worker.py
+│   │   ├── market_profile.py
+│   │   └── mt5_interface.py
+│   ├── ui/
+│   │   ├── chart_widget.py
+│   │   ├── control_panel.py
+│   │   └── main_window.py
+│   ├── config.py
+│   └── main.py
+├── tests/
+│   ├── test_interactive_chart.py
+│   ├── test_logic.py
+│   ├── test_profile_logic.py
+│   └── verify_levels.py
+├── .gitattributes
+├── .gitignore
+├── IDEA.md
+├── LICENSE
+├── market_profile_paper.tex
+├── README.md
+├── requirements.txt
+└── TECHSTACK.md
+```

TECHSTACK.md

@@ -0,0 +1,14 @@
+## Techstack
+
+Audit of **mBA-Terminal** project files (excluding environment and cache):
+
+| File Type | Count | Size (KB) |
+| :--- | :--- | :--- |
+| Python (.py) | 15 | 62.1 |
+| (no extension) | 3 | 1.1 |
+| CSV (.csv) | 3 | 426,797.2 |
+| Markdown (.md) | 2 | 4.9 |
+| PNG Image (.png) | 2 | 482.2 |
+| LaTeX (.tex) | 1 | 31.3 |
+| Plain Text (.txt) | 1 | 0.1 |
+| **Total** | **27** | **427,379.1** |

market_profile_paper.tex

@@ -0,0 +1,730 @@
+\documentclass[conference]{IEEEtran}
+
+% ─── Packages ───────────────────────────────────────────
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{amsmath, amssymb, amsfonts}
+\usepackage{graphicx}
+\usepackage{booktabs}
+\usepackage{hyperref}
+\usepackage{float}
+\usepackage{caption}
+\usepackage{subcaption}
+\usepackage{xcolor}
+\usepackage{enumitem}
+\usepackage{cite}
+\usepackage{array}
+\usepackage{url}
+
+\hypersetup{
+    colorlinks=true,
+    linkcolor=blue!70!black,
+    citecolor=blue!70!black,
+    urlcolor=blue!60!black,
+}
+
+% ─── Title ──────────────────────────────────────────────
+\title{mBA-Profile: Market Profile Construction from Microsecond Bid-Ask Unit Data Using The Path-weighted  Gap-filling Approach}
+
+\author{
+    \IEEEauthorblockN{
+        Rembrant Oyangoren Albeos~%
+        \href{https://orcid.org/0009-0006-8743-4419}{%
+            \includegraphics[height=8pt]{ORCID_icon.png}%
+        }%
+        \textsuperscript{\hyperref[sec:author_info]{$\dagger$}}
+    }
+    \IEEEauthorblockA{%
+        \includegraphics[height=7pt]{ContinualQuasars_icon.png}\hspace{0.4em}Continual Quasars\\
+    }
+}
+
+\begin{document}
+\maketitle
+
+% ════════════════════════════════════════════════════════
+\begin{abstract}
+Conventional market profile construction collapses raw price data
+directly into a Y-distribution histogram, recording only the price
+levels that were explicitly quoted by the exchange or broker feed.
+This paper presents an alternative approach---termed
+\emph{path-weighted gap-filling}---in which synthetic trail-datapoints
+are inserted at every intermediate unit-level price between
+consecutive observations, producing an extended dataset that yields a
+substantially denser and more continuous market profile.  The
+modelling is grounded in microsecond-resolution raw bid/ask unit data
+rather than aggregated TOHLC (time, open, high, low, close) bars or
+volume figures, thereby preserving the highest available fidelity of
+the underlying price process.  We demonstrate the approach on a full
+trading day of \texttt{XAUUSDc} data collected from a live trading
+environment, and show that the gap-filled profile eliminates the empty
+bins and sparse regions that afflict raw-unit profiles during fast
+directional moves, producing a more representative picture of
+intraday price dynamics. All resources and code used in this work are available on GitHub at \url{https://github.com/ContinualQuasars/mBA-Profile}.
+
+\end{abstract}
+
+\begin{IEEEkeywords}
+Market profile, unit data, microsecond bid--ask, market microstructure, path-weighted, gap-filling.
+\end{IEEEkeywords}
+
+% ════════════════════════════════════════════════════════
+\section{Introduction}
+\label{sec:intro}
+
+\subsection{Market Microstructure and Unit Data}
+
+At the most granular level of market data, financial instruments are
+quoted through discrete data updates: each update represents a change in
+the best bid price, the best ask price, or both
+simultaneously~\cite{hasbrouck2007,ohara1995}.  Modern trading
+platforms such as MetaTrader~5 (MT5) record these events with
+millisecond-resolution timestamps, and the data is made available
+through a Python API~\cite{mt5docs}.
+
+The instrument studied in this paper is \texttt{XAUUSDc}, a
+gold CFD (Contract for Difference) traded on a
+standard cent live trading account provided by the Exness broker,
+accessed through the MT5 platform.  The \texttt{c} suffix in
+\texttt{XAUUSDc} is an Exness broker account-type indicator
+(denoting a standard cent live account) and has no bearing on the
+XAU price data itself---extracting data from \texttt{XAUUSDc}
+(cent account) or \texttt{XAUUSDm} (dollar account) yields the
+same XAUUSD price data with three decimal places.  The minimum price
+increment for this instrument is exactly \$0.001.
+Because the standard lot size for gold is 100 troy ounces, a single
+price movement of \$0.001 corresponds to a profit-or-loss change of
+\$0.10 per standard lot.  In this study, the market profile
+bin size is set to \$0.01 (one unit, where 0.01~unit = \$0.01 XAU
+price change), to produce a more
+stable and interpretable distribution.
+
+\subsection{The Market Profile Concept}
+
+A market profile is a rotated histogram of price over a defined time
+window.  The concept was introduced by J.~Peter Steidlmayer at the
+Chicago Board of Trade in the 1980s~\cite{steidlmayer1986}.
+Traditionally, a market profile uses 30-minute ``Time Price
+Opportunity'' (TPO) letters stacked at each price level to show where
+price spent the most time during a trading session~\cite{dalton2007}.
+The horizontal axis represents frequency or time density, while the
+vertical axis represents price.
+
+In this study, the concept is adapted to microsecond unit data.
+Instead of 30-minute TPO letters, each histogram bar represents the
+number of data updates (or interpolated price levels, in the
+gap-filled approach) observed at that price.  The construction is
+based exclusively on raw bid/ask unit data---not on TOHLC candles or
+volume bars---ensuring that no information is lost to
+aggregation~\cite{ane2000,engle2000}.
+
+\subsection{Paper Outline}
+
+Section~\ref{sec:data} describes the data acquisition pipeline and
+the dataset used.  Section~\ref{sec:raw} details the raw unit
+approach.  Section~\ref{sec:filled} introduces the gap-filled
+(path-weighted) approach, including a detailed explanation of why
+path-weighting is used.  Section~\ref{sec:comparison} provides a
+comprehensive comparison of the two approaches.
+Section~\ref{sec:conclusion} concludes.
+
+
+% ════════════════════════════════════════════════════════
+\section{Data Acquisition}
+\label{sec:data}
+
+\subsection{Trading Environment}
+
+The unit data used in this study was collected from a standard cent
+live trading account on the Exness broker, accessed through MetaTrader~5.
+MT5 is a multi-asset trading platform developed by MetaQuotes Software
+Corp.\ that is widely used for forex and CFD
+trading~\cite{mt5docs,metaquotes2024}.  Its Python integration exposes
+the function \texttt{copy\_ticks\_range()}, which returns every data
+update within a specified time window as a structured NumPy
+array~\cite{numpy2020}.  Each data record contains the following
+fields: a Unix timestamp in seconds, a millisecond-precision timestamp
+providing sub-second resolution, the best bid price, the best ask
+price, and additional metadata including flags indicating which fields
+changed on that particular update.
+
+Although the exposed timestamp has millisecond granularity, the MT5
+documentation describes the system as operating at microsecond
+internal resolution~\cite{mt5docs}; the millisecond field is what is
+exposed through the Python API.
+
+\subsection{Dataset Summary}
+
+The symbol is \texttt{XAUUSDc}.  The time range covers the full UTC
+day of February~12, 2026, from 00:00:00 to 23:59:59.  The flag used
+retrieves all data updates regardless of whether the bid, ask, or last
+price changed.
+
+The query returned exactly \textbf{393,252~data points}.  The first data point was
+recorded at \textbf{2026-02-12 00:00:00.149~UTC} and the last data point at
+\textbf{2026-02-12 23:59:57.820~UTC}.  The bid price ranged from a
+low of \textbf{\$4,878.380} to a high of \textbf{\$5,083.750}, a span
+of \textbf{\$205.370} (20,537~units).  The ask price ranged from
+\textbf{\$4,878.620} to \textbf{\$5,083.990}, a span of
+\textbf{\$205.370} (20,537~units).
+
+\subsection{Unit Size}
+
+The unit size for \texttt{XAUUSDc} is \textbf{\$0.010} (0.01~unit,
+where 0.01~unit = \$0.01 XAU price change).
+This value is determined by the broker's symbol specification and is
+not configurable by the user.  The lowest price resolution of XAU is
+three decimal places: a change of 0.001 corresponds to a
+\$0.001 price movement.  Throughout this paper, $\delta = 0.010$
+denotes the unit size, and the bin width used for histogram
+construction equals 0.01~unit ($w = \delta = 0.010$).
+
+
+% ════════════════════════════════════════════════════════
+\section{Approach~1: Raw Unit Y-Distribution}
+\label{sec:raw}
+
+\subsection{Methodology}
+
+The raw unit approach constructs a market profile histogram directly
+from the 393,252 observed unit prices without any interpolation or
+modification.  The procedure begins by extracting the bid and ask
+columns as separate arrays from the dataset.  Histogram bin edges are
+computed starting from
+$\lfloor p_{\min}/\delta \rfloor \cdot \delta - \delta$ up to
+$\lceil p_{\max}/\delta \rceil \cdot \delta + \delta$, spaced by
+exactly $\delta = 0.010$.  This ensures that every observed price
+falls cleanly within a bin whose width is exactly 0.01~unit.  Bin edges
+are rounded to avoid floating-point precision
+artefacts~\cite{goldberg1991}.
+
+A standard frequency histogram is then computed---the count of data points
+whose price falls within each bin---separately for bid and ask.  The
+histogram is plotted horizontally, with price on the vertical axis and
+count on the horizontal axis, creating the conventional market-profile
+appearance where the thickest region corresponds to the price level
+that received the most data updates.
+
+\subsection{Feature Engineering}
+
+The feature engineering pipeline for the raw approach consists of the
+following stages.  First, the raw unit data from MT5 (a structured
+array) is converted into a tabular format.  The millisecond-precision
+timestamp column is transformed into a UTC-aware datetime
+representation.  Next, the datetime values are converted to
+floating-point date numbers suitable for high-performance
+plotting~\cite{matplotlib2007}.  This pre-conversion is performed once
+before plotting because passing raw datetime objects to the plotting
+library triggers an internal per-element conversion that is extremely
+slow for arrays of 393,252 elements---the pre-conversion reduces
+plotting time from several minutes to under one minute for the full
+dataset.
+
+The histogram bin edges are constructed using a range function with
+step size equal to $\delta$ and then rounded.  For the observed data
+range of \$4,878.380 to \$5,083.990, this produces 20,563 bin edges
+defining 20,562 bins, each exactly \$0.010 wide (0.01~unit).
+
+\subsection{Output}
+
+The output is a $2 \times 2$ subplot figure.  The top row displays the
+bid data: a horizontal histogram on the left (blue) and a time-series
+line chart on the right (blue).  The bottom row displays the ask data
+in the same layout using red.  The two rows share their respective
+Y-axes so that price levels align horizontally between the histogram
+and the line chart.
+
+\begin{figure*}[t]
+    \centering
+    \includegraphics[width=\textwidth]{raw_ticks_4panel.png}
+    \caption{Raw unit Y-distribution histograms (left column) and
+    time-series line charts (right column) for bid (top, blue) and ask
+    (bottom, red) prices of \texttt{XAUUSDc} on February~12, 2026.
+    The dataset contains 393,252 data points.  Bin size = 0.01~unit (\$0.010).
+    The histogram X-axis shows the count of data points observed at each
+    price level.}
+    \label{fig:raw_4panel}
+\end{figure*}
+
+\subsection{Interpretation}
+
+In the raw histogram (Figure~\ref{fig:raw_4panel}), the count at each
+price level reflects how many times the market's best bid or best ask
+was updated to that exact price.  Levels where the market
+consolidated---spending extended time with many small quote
+updates---accumulate high counts and form the thick horizontal bars in
+the profile~\cite{dalton2007}.
+
+However, when the market jumps from price $A$ to price $B$ in a single
+update without quoting any intermediate level, those intermediate levels
+receive zero counts in the histogram.  The raw profile therefore
+contains \emph{gaps}---entire price levels with no
+representation---that correspond to fast directional moves.  This is a
+fundamental limitation: the profile faithfully records only what was
+quoted, but it does not capture the price path traversed between
+observations.  This motivates the gap-filled approach presented in
+Section~\ref{sec:filled}.
+
+
+% ════════════════════════════════════════════════════════
+\section{Approach~2: Gap-Filled (Path-Weighted) Y-Distribution}
+\label{sec:filled}
+
+\subsection{Motivation}
+
+Consider a scenario where the bid price moves from \$5,060.000 to
+\$5,060.100 in a single update.  In the raw approach, only two price
+levels---\$5,060.000 and \$5,060.100---register a count, while the
+eight intermediate levels (\$5,060.010 through \$5,060.090) receive no
+representation at all.  Yet, under the assumption that price is a
+continuous process sampled at discrete intervals, the price must have
+traversed those eight levels to arrive at
+\$5,060.100~\cite{cont2001,bacry2012}.  The gap-filled approach
+addresses this by inserting synthetic trail-datapoints at every
+intermediate unit-level price between consecutive observations,
+thereby constructing a profile that reflects the full path traversed
+by the market rather than only the endpoints of each move.
+
+\subsection{Why Path-Weighting?}
+\label{sec:whypathweight}
+
+The term \emph{path-weighted} refers to the fact that each price
+level's histogram count is weighted by the number of times the price
+path crossed that level, not merely the number of times it was
+explicitly quoted.  The rationale for this weighting rests on three
+observations:
+
+\begin{enumerate}[leftmargin=*]
+    \item \textbf{Continuity of the price process.}  Financial prices
+    are fundamentally continuous stochastic processes sampled at
+    discrete intervals by the exchange or broker
+    feed~\cite{cont2001,bacry2012}.  Between any two consecutive
+    observations at prices $p_A$ and $p_B$, the underlying price
+    process must have traversed every intermediate level.  The raw
+    profile discards this traversal information; the path-weighted
+    profile recovers it.
+
+    \item \textbf{Elimination of empty bins.}  In the raw profile,
+    fast directional moves produce stretches of price levels with zero
+    counts, creating discontinuities in the histogram that can mislead
+    visual interpretation.  Path-weighting ensures that every price
+    level between $p_{\min}$ and $p_{\max}$ receives a non-zero count,
+    producing a continuous and visually coherent
+    profile~\cite{steidlmayer1986}.
+
+    \item \textbf{Traversal as a proxy for significance.}  A price
+    level that is crossed repeatedly---even by fast-moving price
+    swings that do not dwell there---is a level that the market
+    revisits often.  Such levels frequently correspond to support,
+    resistance, or areas of high liquidity~\cite{dalton2007,
+    steidlmayer1986}.  Path-weighting captures this repeated-traversal
+    signal, which raw unit counting misses entirely.
+\end{enumerate}
+
+In summary, path-weighting transforms the market profile from a
+histogram of \emph{quoting intensity} into a histogram of
+\emph{traversal frequency}, which is a richer and more informative
+representation of where the market has been.
+
+\subsection{Algorithm}
+
+The gap-filling algorithm operates on pairs of consecutive data points.  For
+each pair $(A, B)$ with prices $p_A$ and $p_B$ and timestamps $t_A$
+and $t_B$ (represented as nanosecond integers for computational
+efficiency), the algorithm first computes the signed unit difference
+$\Delta n = \text{round}((p_B - p_A) / \delta)$.  If
+$|\Delta n| \le 1$, no interpolation is needed because the two prices
+are adjacent or identical, and the pair is left unchanged.  If
+$|\Delta n| > 1$, the algorithm inserts $|\Delta n| - 1$ intermediate
+rows.  Each intermediate row $k$ (where $1 \le k < |\Delta n|$)
+receives a price of
+$p_A + k \cdot \text{sgn}(\Delta n) \cdot \delta$ and a timestamp of
+$t_A + \frac{k}{|\Delta n|} \cdot (t_B - t_A)$.  The timestamp
+interpolation is linear, distributing the intermediate points evenly
+across the time interval between data points $A$ and
+$B$~\cite{dacorogna2001}.
+
+The implementation is fully vectorised using array operations rather
+than interpreted loops~\cite{numpy2020}.  The key operations are
+element repetition (to repeat each source index by the number of units
+in its segment), cumulative summation (to compute segment start
+positions), and element-wise arithmetic for price and timestamp
+interpolation.  This vectorised approach processes the entire
+393,252-point dataset in under 2~seconds on a consumer-grade machine.
+
+The gap-filling is applied independently to the bid series and the ask
+series because the bid and ask prices can move by different amounts on
+the same data update.  After gap-filling, the bid series expands from
+393,252 rows to exactly \textbf{4,614,400~rows} (an expansion factor
+of $11.73\times$), and the ask series expands from 393,252 rows to
+exactly \textbf{4,619,918~rows} (an expansion factor of
+$11.75\times$).
+
+\subsection{Feature Engineering}
+
+The feature engineering pipeline for the gap-filled approach shares the
+initial stages with the raw approach: data fetching, tabular
+conversion, and datetime derivation are identical.  The additional
+stage is the gap-filling itself, which produces two new arrays of
+expanded prices and their corresponding interpolated timestamps.
+
+For plotting, the expanded nanosecond timestamps must be converted to
+floating-point date numbers.  Because the expanded arrays contain
+approximately 4.6 million elements, calling a datetime conversion
+function on individual objects would be prohibitively slow.  Instead,
+the conversion is performed arithmetically: the nanosecond integer is
+divided by $10^9$ to get seconds, then by 86,400 to get fractional
+days since the Unix epoch, and finally offset by the appropriate
+constant to align with the plotting library's date
+system~\cite{matplotlib2007}.  This bypasses all object-level datetime
+creation and processes the 4.6 million timestamps in a single
+vectorised operation.
+
+The histogram bins are constructed identically to the raw approach,
+using 0.01-unit (\$0.010) bin widths.  Because the gap-filled data has
+the same price range as the raw data (\$4,878.380 to \$5,083.990),
+the number of bins is also 20,562.
+
+\subsection{Output}
+
+The output figure has the identical $2 \times 2$ subplot layout as
+Figure~\ref{fig:raw_4panel}.
+
+\begin{figure*}[t]
+    \centering
+    \includegraphics[width=\textwidth]{filled_ticks_4panel.png}
+    \caption{Gap-filled (path-weighted) Y-distribution histograms
+    (left column) and time-series line charts (right column) for bid
+    (top, blue) and ask (bottom, red) prices of \texttt{XAUUSDc} on
+    February~12, 2026.  The bid series contains 4,614,400 data points
+    and the ask series contains 4,619,918 data points after
+    gap-filling.  Bin size = 0.01~unit (\$0.010).  The histogram X-axis
+    shows the path-weighted count: the number of times each price
+    level was traversed between consecutive data points, including synthetic
+    intermediate points.}
+    \label{fig:filled_4panel}
+\end{figure*}
+
+\subsection{Interpretation}
+
+The gap-filled histogram (Figure~\ref{fig:filled_4panel}) answers a
+fundamentally different question than the raw histogram.  Where the
+raw profile asks ``how many times was price \emph{quoted} at this
+level,'' the gap-filled profile asks ``how many times did the price
+\emph{path} cross this level.''  The practical consequence is visible
+in the histogram scale: the raw histogram peaks at counts near 120,
+while the gap-filled histogram peaks at counts near 1,200 (consistent
+with the $\approx 11.7\times$ average expansion factor).
+
+Price regions that were traversed frequently---even if the market did
+not dwell there long enough to generate many raw tick
+updates---accumulate higher counts in the gap-filled profile.  The
+large sell-off visible around 16:00~UTC, where the bid price dropped
+from the \$5,050.000 region to the \$4,878.000 region in a
+concentrated burst of activity, produces substantial counts at every
+intermediate price level in the gap-filled profile, whereas those same
+levels appear sparse or empty in the raw profile because the market
+jumped through them in large increments.
+
+
+% ════════════════════════════════════════════════════════
+\section{Raw vs.\ Gap-Filled: Comprehensive Comparison}
+\label{sec:comparison}
+
+\subsection{What Each Approach Measures}
+
+The raw approach counts only actual tick updates from the broker's
+data feed.  When a price level receives a high count, it means the
+market's best bid or ask was actively updated to that level many
+times.  This is a direct measurement of \emph{quoting
+intensity}~\cite{ohara1995}: how frequently market participants were
+placing or modifying orders at that price.
+
+The gap-filled approach counts every tick-level price between
+consecutive updates, including synthetic intermediate points that were
+never explicitly quoted.  When a price level receives a high count in
+the gap-filled profile, it means the price \emph{path} crossed that
+level many times---either through actual quoting or through
+interpolation during price jumps.  This is a measurement of
+\emph{traversal frequency}.
+
+\subsection{Detailed Comparison}
+
+Table~\ref{tab:comparison} presents a comprehensive side-by-side
+comparison of the two approaches across all relevant variables.
+
+\begin{table*}[t]
+\centering
+\caption{Comprehensive comparison of raw tick vs.\ gap-filled
+(path-weighted) market profile construction for \texttt{XAUUSDc} on
+February~12, 2026.}
+\label{tab:comparison}
+\small
+\begin{tabular}{@{}p{3.8cm}p{5.8cm}p{5.8cm}@{}}
+\toprule
+\textbf{Variable} & \textbf{Raw Tick Profile} & \textbf{Gap-Filled (Path-Weighted) Profile} \\
+\midrule
+Data source &
+Microsecond bid/ask ticks from MT5 &
+Same raw ticks, plus synthetic trail-datapoints \\
+\midrule
+Bid data points &
+393,252 &
+4,614,400 ($11.73\times$ expansion) \\
+\midrule
+Ask data points &
+393,252 &
+4,619,918 ($11.75\times$ expansion) \\
+\midrule
+Price range &
+\$4,878.380 -- \$5,083.990 &
+\$4,878.380 -- \$5,083.990 (identical) \\
+\midrule
+Bin width &
+$\delta = \$0.010$ (1 tick) &
+$\delta = \$0.010$ (1 tick, identical) \\
+\midrule
+Number of bins &
+20,562 &
+20,562 (identical) \\
+\midrule
+Avg.\ count per bin (bid) &
+$393{,}252 / 20{,}537 \approx 19.15$ &
+$4{,}614{,}400 / 20{,}537 \approx 224.7$ \\
+\midrule
+Peak histogram count &
+$\sim$120 &
+$\sim$1,200 \\
+\midrule
+Empty bins in profile &
+Many (fast moves leave gaps) &
+None (all intermediate levels filled) \\
+\midrule
+Profile continuity &
+Discontinuous; sparse in trending regions &
+Continuous; no gaps across entire price range \\
+\midrule
+What is measured &
+Quoting intensity (how often each level was quoted) &
+Traversal frequency (how often price path crossed each level) \\
+\midrule
+Consolidation zones &
+High counts---dense, well-represented &
+Similar to raw (few gaps to fill when moves are small) \\
+\midrule
+Fast directional moves &
+Sparse or empty---underrepresented &
+Well-represented with interpolated traversals \\
+\midrule
+Support/resistance detection &
+Based on quoting density only &
+Enhanced: repeated traversals indicate revisited levels \\
+\midrule
+Interpolation method &
+None &
+Linear timestamp interpolation, tick-step price fill \\
+\midrule
+Computational cost &
+Minimal (direct histogram of raw data) &
+Higher ($\sim$11.7$\times$ more data to process) \\
+\bottomrule
+\end{tabular}
+\end{table*}
+
+\subsection{Superiority of the Gap-Filled Approach}
+
+The gap-filled approach produces a fundamentally more representative
+market profile than the raw tick approach.  Its advantages are
+threefold:
+
+\begin{enumerate}[leftmargin=*]
+    \item \textbf{Complete price coverage.}  The gap-filled profile
+    assigns a non-zero count to every price level within the day's
+    range, eliminating the misleading empty bins that appear in the
+    raw profile during fast moves.  This provides a structurally
+    complete picture of where the market traded.
+
+    \item \textbf{Traversal information.}  By counting path crossings
+    rather than only explicit quotes, the gap-filled profile captures
+    information about how frequently the market revisited each price
+    level---information that is entirely absent from the raw profile.
+    This traversal signal is directly relevant to identifying dynamic
+    support and resistance~\cite{dalton2007}.
+
+    \item \textbf{Robustness to feed granularity.}  Different brokers
+    and feed providers update tick data at different rates.  A slower
+    feed produces larger jumps between consecutive ticks, which
+    creates more gaps in the raw profile.  The gap-filled approach is
+    robust to this variation because it reconstructs the intermediate
+    path regardless of the feed's update frequency.
+\end{enumerate}
+
+The primary trade-off is computational cost: the gap-filling process
+multiplies the dataset by a factor of approximately $11.7\times$ in
+this study, which proportionally increases the time required for
+histogram computation and rendering compared to a typical raw-data
+market profile.  For very long time horizons or very volatile
+instruments, this expansion factor could be significantly larger.
+
+\subsection{Interaction with Bin Size}
+
+At the 1-tick bin width ($w = 0.010$) used throughout this study,
+the difference between the raw and gap-filled profiles is maximal
+because gaps in the raw profile (empty bins where no tick was
+observed) are filled in by the gap-filling process.  As the bin width
+increases, the practical difference between the two approaches
+diminishes because larger bins tend to capture at least some ticks
+even in the raw profile, and the synthetic intermediate points are
+absorbed into the same bins as the observed ticks.  At sufficiently
+large bin widths, the raw and gap-filled histograms become nearly
+indistinguishable~\cite{scott1979}.
+
+
+% ════════════════════════════════════════════════════════
+\section{Conclusion}
+\label{sec:conclusion}
+
+This paper presented two approaches to constructing market profiles
+from 393,252 microsecond-resolution bid/ask tick updates of
+\texttt{XAUUSDc} on February~12, 2026, collected from a standard cent
+live trading account on the Exness broker via MetaTrader~5.  The raw
+approach counted only observed tick levels, producing a profile that
+reflects quoting intensity.  The gap-filled (path-weighted) approach
+interpolated every intermediate price level between consecutive ticks,
+expanding the dataset to 4,614,400 bid rows and 4,619,918 ask rows,
+and producing a profile that reflects path traversal frequency.
+
+The gap-filled approach yields a more complete and informative market
+profile by eliminating empty bins, capturing traversal information,
+and providing robustness to variations in feed update frequency.  The
+primary cost of this approach is computational: the gap-filling
+process multiplies the dataset size by a factor of approximately
+$11.7\times$, which may result in slower calculation times compared to
+typical market profile construction from raw data.
+
+%% ============================================================================
+%% AUTHOR INFORMATION
+%% ============================================================================
+\newpage
+\vspace{2em}
+\section*{Author Information}
+\label{sec:author_info}
+
+\begin{center}
+\textbf{Rembrant Oyangoren Albeos}~\href{https://orcid.org/0009-0006-8743-4419}{\includegraphics[height=10pt]{ORCID_icon.png}}
+\end{center}
+
+\noindent\textbf{ORCID:} \url{https://orcid.org/0009-0006-8743-4419}
+
+\noindent\textbf{Email:} algorembrant@gmail.com
+
+\noindent\textbf{Affiliation:} Developer \& Researcher at ConQ
+
+\noindent\textbf{Organization:} Continual Quasars~\includegraphics[height=7pt]{ContinualQuasars_icon.png}
+
+\noindent\textbf{Organization GitHub:} \url{https://github.com/ContinualQuasars}
+
+\noindent\textbf{This Version:} Febuary 14, 2026
+
+\noindent\textbf{GitHub:} \url{https://github.com/ContinualQuasars/mBA-Profile}
+
+
+% ════════════════════════════════════════════════════════
+\newpage
+\vspace{20}
+\begin{thebibliography}{99}
+
+\bibitem{steidlmayer1986}
+J.~P. Steidlmayer and K.~Koy,
+\textit{Markets and Market Logic},
+Porcupine Press, 1986.
+
+\bibitem{dalton2007}
+J.~Dalton, E.~Jones, and R.~Dalton,
+\textit{Mind Over Markets: Power Trading with Market Generated
+Information}, Wiley, 2007.
+
+\bibitem{mt5docs}
+MetaQuotes Software Corp.,
+``MetaTrader~5 Python Integration,''
+\url{https://www.mql5.com/en/docs/python_metatrader5}, 2024.
+
+\bibitem{metaquotes2024}
+MetaQuotes Software Corp.,
+``MetaTrader~5 Trading Platform,''
+\url{https://www.metatrader5.com}, 2024.
+
+\bibitem{ohara1995}
+M.~O'Hara,
+\textit{Market Microstructure Theory},
+Blackwell Publishers, 1995.
+
+\bibitem{hasbrouck2007}
+J.~Hasbrouck,
+\textit{Empirical Market Microstructure: The Institutions, Economics,
+and Econometrics of Securities Trading},
+Oxford University Press, 2007.
+
+\bibitem{cont2001}
+R.~Cont,
+``Empirical properties of asset returns: Stylized facts and
+statistical issues,''
+\textit{Quantitative Finance}, vol.~1, no.~2, pp.~223--236, 2001.
+
+\bibitem{bacry2012}
+E.~Bacry, M.~Mastromatteo, and J.-F. Muzy,
+``Hawkes processes in finance,''
+\textit{Market Microstructure and Liquidity}, vol.~1, no.~1, 2015.
+
+\bibitem{dacorogna2001}
+M.~M. Dacorogna, R.~Gen\c{c}ay, U.~A. M\"{u}ller, R.~B. Olsen, and
+O.~V. Pictet,
+\textit{An Introduction to High-Frequency Finance},
+Academic Press, 2001.
+
+\bibitem{engle2000}
+R.~F. Engle and J.~R. Russell,
+``Autoregressive conditional duration: A new model for irregularly
+spaced transaction data,''
+\textit{Econometrica}, vol.~66, no.~5, pp.~1127--1162, 1998.
+
+\bibitem{ane2000}
+T.~An\'{e} and H.~Geman,
+``Order flow, transaction clock, and normality of asset returns,''
+\textit{The Journal of Finance}, vol.~55, no.~5, pp.~2259--2284,
+2000.
+
+\bibitem{goldberg1991}
+D.~Goldberg,
+``What every computer scientist should know about floating-point
+arithmetic,''
+\textit{ACM Computing Surveys}, vol.~23, no.~1, pp.~5--48, 1991.
+
+\bibitem{numpy2020}
+C.~R. Harris \textit{et al.},
+``Array programming with NumPy,''
+\textit{Nature}, vol.~585, pp.~357--362, 2020.
+
+\bibitem{matplotlib2007}
+J.~D. Hunter,
+``Matplotlib: A 2D graphics environment,''
+\textit{Computing in Science \& Engineering}, vol.~9, no.~3,
+pp.~90--95, 2007.
+
+\bibitem{cmegroup2024}
+CME Group,
+``Gold Futures Contract Specifications,''
+\url{https://www.cmegroup.com/markets/metals/precious/gold.contractSpecs.html},
+2024.
+
+\bibitem{scott1979}
+D.~W. Scott,
+``On optimal and data-based histograms,''
+\textit{Biometrika}, vol.~66, no.~3, pp.~605--610, 1979.
+
+\end{thebibliography}
+
+
+
+\end{document}
+

output/filled_ask_XAUUSDc_20260212.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4bb8d664f7c5a62ba89c59050d50b5af3a23ac9fc97055ae7bcd62cd18aa007b
+size 206497481

output/filled_bid_XAUUSDc_20260212.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39ea0b63d98e6b8127956f9546e210088e2a132c6ae497b1b9c16bade40e2f3a
+size 206250499

output/raw_ticks_XAUUSDc_20260212.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2d65fb9a10b9979529a28551b3be2ddf2bb30487f00c3d1267bdf214563b957a
+size 24292358

requirements.txt

@@ -0,0 +1,11 @@
+MetaTrader5
+pandas
+numpy
+matplotlib
+datetime
+
+PyQt6 
+pyqtgraph 
+MetaTrader5 
+pandas 
+numpy

scripts/debug_mt5.py

@@ -0,0 +1,87 @@
+
+import sys
+import os
+import MetaTrader5 as mt5
+from datetime import datetime
+
+# Add project root to sys.path
+current_dir = os.path.dirname(os.path.abspath(__file__))
+project_root = os.path.dirname(current_dir)
+sys.path.insert(0, project_root)
+
+try:
+    import src.config as config
+except ImportError:
+    print("Error: Could not import src.config")
+    config = None
+
+def test_connection():
+    print("=== MT5 Connection Debugger ===")
+    print(f"Python: {sys.version}")
+    print(f"MT5 Package Version: {mt5.__version__}")
+    print(f"MT5 Package Author: {mt5.__author__}")
+    
+    path = getattr(config, 'MT5_PATH', '')
+    login = getattr(config, 'MT5_LOGIN', 0)
+    server = getattr(config, 'MT5_SERVER', '')
+    password = getattr(config, 'MT5_PASSWORD', '')
+    
+    print(f"\nConfigured Path: '{path}'")
+    print(f"Configured Login: {login}")
+    print(f"Configured Server: '{server}'")
+    print(f"Configured Password: {'******' if password else 'Not Set'}")
+    
+    print("\nAttempting Initialization...")
+    
+    if path:
+        if not mt5.initialize(path=path):
+            print(f"FAILED: mt5.initialize(path='{path}')")
+            print(f"Error Code: {mt5.last_error()}")
+            return
+    else:
+        if not mt5.initialize():
+            print("FAILED: mt5.initialize()")
+            print(f"Error Code: {mt5.last_error()}")
+            print("Tip: If you have multiple MT5 terminals or it's installed in a custom location, set MT5_PATH in src/config.py")
+            return
+
+    print("SUCCESS: MT5 Initialized.")
+    
+    # Check Terminal Info
+    terminal_info = mt5.terminal_info()
+    if terminal_info:
+        print("\nTerminal Info:")
+        print(f"  Path: {terminal_info.path}")
+        print(f"  Name: {terminal_info.name}")
+        print(f"  Company: {terminal_info.company}")
+        print(f"  Connected: {terminal_info.connected}")
+    else:
+        print("WARNING: Could not get terminal info.")
+
+    # Check Account Info
+    account_info = mt5.account_info()
+    if account_info:
+        print("\nAccount Info (Current):")
+        print(f"  Login: {account_info.login}")
+        print(f"  Server: {account_info.server}")
+        print(f"  Variable Margin: {account_info.margin_so_mode}")
+    else:
+        print("\nWARNING: No account currently logged in or accessible.")
+        
+    # Attempt Login if provided
+    if login and password and server:
+        print(f"\nAttempting Login to {login} on {server}...")
+        authorized = mt5.login(login=login, password=password, server=server)
+        if authorized:
+            print("SUCCESS: Authorized.")
+            account_info = mt5.account_info()
+            print(f"  Balance: {account_info.balance}")
+            print(f"  Equity: {account_info.equity}")
+        else:
+            print(f"FAILED: Login failed. Error: {mt5.last_error()}")
+    
+    mt5.shutdown()
+    print("\nDisconnected.")
+
+if __name__ == "__main__":
+    test_connection()

src/config.py

@@ -0,0 +1,48 @@
+import os
+from datetime import time
+import pytz
+
+# ──────────────────────────────────────────────
+# Global Configuration
+# ──────────────────────────────────────────────
+
+# MT5 Connection
+MT5_PATH = r""  # Path to terminal64.exe, e.g., r"C:\Program Files\MetaTrader 5\terminal64.exe"
+MT5_LOGIN = 0   # Account number (int)
+MT5_PASSWORD = "" # Account password
+MT5_SERVER = ""   # Broker server name
+
+DEFAULT_SYMBOL = "XAUUSD"
+TIMEFRAME = 1  # 1 minute for basic candles if needed, but we focus on ticks
+
+# Market Profile Settings
+# Session defined as 22:00 UTC (previous day) to 00:00 UTC (current day) as per request?
+# Actually user said: "after the feature-engineered micro marketprofile is established at 22 UTC to 0 UTC, then make sure there is a developing VAH VAL and POC line."
+# This implies the "profile building" phase is 22:00 -> 00:00.
+# And "developing" lines start from 00:00 onwards?
+# We will define the PROFILE_START_TIME and PROFILE_END_TIME.
+
+TIMEZONE_UTC = pytz.utc
+PROFILE_START_TIME = time(22, 0, 0)  # 22:00 UTC
+PROFILE_END_TIME = time(0, 0, 0)     # 00:00 UTC (next day effectively)
+
+# The user might mean a 2-hour window [22, 00) to build the initial profile?
+# Or maybe the "day" starts at 22:00 UTC?
+# "focus on ... gap-filled ... approach ... established at 22 UTC to 0 UTC"
+# Let's assume we use data from 22:00 (prev day) to 00:00 (current day) to ESTABLISH the levels.
+# And then we CONTINUE updating/developing them? Or we use those fixed levels?
+# "make sure there is a developing VAH VAL and POC line." -> implies they continue to evolve?
+# Or maybe they start plotting from 00:00 based on the 22-00 data?
+# I will implement it such that the profile *accumulates* starting from a specialized time.
+
+# Visualization Colors
+COLOR_BID = '#0000FF'   # Blue
+COLOR_ASK = '#FF0000'   # Red
+COLOR_VAH = '#00FF00'   # Green
+COLOR_VAL = '#FF00FF'   # Magenta
+COLOR_POC = '#FFFF00'   # Yellow
+COLOR_BACKGROUND = '#000000'
+COLOR_TEXT = '#FFFFFF'
+
+# Technical
+UNIT_SIZE = 0.01  # For XAUUSD, $0.01

src/core/data_worker.py

@@ -0,0 +1,165 @@
+import time
+from datetime import datetime, timedelta, timezone
+import pandas as pd
+import numpy as np
+from PyQt6.QtCore import QThread, pyqtSignal, QObject
+
+from src.core.mt5_interface import MT5Interface
+from src.core.market_profile import MarketProfile
+
+class DataWorker(QThread):
+    # Signals
+    data_signal = pyqtSignal(object, object) # ticks_df, profile_counts
+    levels_signal = pyqtSignal(object, object, object, object) # times, vah, val, poc (can be arrays or scalars)
+    status_signal = pyqtSignal(str)
+    finished_signal = pyqtSignal()
+    
+    def __init__(self, symbol, date_obj, multiplier=1.0):
+        super().__init__()
+        self.symbol = symbol
+        self.date_obj = date_obj 
+        self.multiplier = multiplier
+        self.running = True
+        self.mt5_interface = MT5Interface()
+        self.market_profile = MarketProfile(multiplier=self.multiplier)
+        
+    def run(self):
+        self.status_signal.emit(f"Connecting to MT5... (Multiplier: {self.multiplier}x)")
+        if not self.mt5_interface.initialize():
+            self.status_signal.emit("Failed to connect to MT5.")
+            self.finished_signal.emit()
+            return
+
+        # Calculate session times
+        # Target Date (00:00 UTC of the selected day)
+        target_date_utc = datetime(self.date_obj.year, self.date_obj.month, self.date_obj.day, tzinfo=timezone.utc)
+        
+        # Establishment Start: 22:00 UTC previous day
+        start_establishment = target_date_utc - timedelta(days=1) + timedelta(hours=22)
+        # Establishment End (Developing Start): 00:00 UTC target day
+        end_establishment = target_date_utc
+        # Session End: 00:00 UTC next day (24h later)
+        end_session = target_date_utc + timedelta(days=1)
+        
+        # Current time
+        now_utc = datetime.now(timezone.utc)
+        
+        # Determine Fetch Range
+        is_historical = end_session < now_utc
+        fetch_end = end_session if is_historical else now_utc
+        
+        self.status_signal.emit(f"Fetch Range: {start_establishment} to {fetch_end} ...")
+        
+        # 1. Fetch History
+        ticks_df = self.mt5_interface.get_ticks(self.symbol, start_establishment, fetch_end)
+        
+        if not ticks_df.empty:
+            # Split Data
+            mask_est = (ticks_df['datetime'] >= start_establishment) & (ticks_df['datetime'] < end_establishment)
+            df_est = ticks_df.loc[mask_est]
+            
+            mask_dev = (ticks_df['datetime'] >= end_establishment)
+            df_dev = ticks_df.loc[mask_dev]
+            
+            self.status_signal.emit(f"Data: {len(ticks_df)} total. Est: {len(df_est)}, Dev: {len(df_dev)}")
+            
+            # 2. Process Establishment Phase
+            if not df_est.empty:
+                self.market_profile.update(df_est)
+                self.status_signal.emit(f"Profile Established. Ticks: {self.market_profile.total_ticks}")
+            else:
+                self.status_signal.emit("Warning: No Establishment Data (22:00-00:00). Starting empty.")
+            
+            # 3. Process Developing Phase (History Replay)
+            dev_times = []
+            dev_vah = []
+            dev_val = []
+            dev_poc = []
+            
+            if not df_dev.empty:
+                # Resample to 1 minute to calculate trajectory
+                df_dev_indexed = df_dev.set_index('datetime')
+                grouped = df_dev_indexed.resample('1min')
+                
+                count_steps = 0
+                for time_idx, group in grouped:
+                    if group.empty:
+                        continue
+                    
+                    # Update profile
+                    group_reset = group.reset_index()
+                    self.market_profile.update(group_reset)
+                    
+                    # Calculate levels
+                    v, l, p = self.market_profile.get_vah_val_poc()
+                    if v is not None:
+                        # Use timestamp
+                        ts_float = time_idx.timestamp()
+                        dev_times.append(ts_float)
+                        dev_vah.append(v)
+                        dev_val.append(l)
+                        dev_poc.append(p)
+                    count_steps += 1
+                
+                self.status_signal.emit(f"Calculated {count_steps} developing points.")
+            
+            # Emit History Data: Ticks
+            # If extremely large, maybe downsample? But for now send all.
+            print(f"DEBUG: Worker Emitting Ticks: {len(ticks_df)}")
+            self.data_signal.emit(ticks_df, self.market_profile.counts)
+            
+            # Emit Levels
+            if dev_times:
+                print(f"DEBUG: Worker Emitting Levels: {len(dev_times)} pts. Times: {dev_times[0]} -> {dev_times[-1]}")
+                self.levels_signal.emit(
+                    np.array(dev_times), 
+                    np.array(dev_vah), 
+                    np.array(dev_val), 
+                    np.array(dev_poc)
+                )
+            else:
+                print("DEBUG: No developing levels calculated to emit.")
+                self.status_signal.emit("No developing levels calculated (insufficient dev data?).")
+
+        else:
+            self.status_signal.emit("No ticks returned from MT5.")
+
+        # 4. Live Streaming (Only if not historical)
+        if not is_historical:
+            self.status_signal.emit("Live streaming active...")
+            
+            last_time = now_utc
+            if not ticks_df.empty:
+                last_time = ticks_df['datetime'].iloc[-1].to_pydatetime()
+            
+            while self.running:
+                time.sleep(1.0)
+                
+                cur_time = datetime.now(timezone.utc)
+                new_ticks = self.mt5_interface.get_ticks(self.symbol, last_time, cur_time + timedelta(seconds=1))
+                
+                if not new_ticks.empty:
+                    new_ticks = new_ticks[new_ticks['datetime'] > last_time]
+                    
+                    if not new_ticks.empty:
+                        self.market_profile.update(new_ticks)
+                        last_time = new_ticks['datetime'].iloc[-1].to_pydatetime()
+                        
+                        # Emit Tick Data
+                        # print(f"DEBUG: Live Tick Update: {len(new_ticks)}")
+                        self.data_signal.emit(new_ticks, self.market_profile.counts)
+                        
+                        # Emit Level Update
+                        v, l, p = self.market_profile.get_vah_val_poc()
+                        if v is not None:
+                            ts_now = cur_time.timestamp()
+                            # print(f"DEBUG: Live Level Update: POC {p}")
+                            self.levels_signal.emit([ts_now], [v], [l], [p])
+        else:
+            self.status_signal.emit("Historical view loaded. Live stream inactive.")
+
+            
+    def stop(self):
+        self.running = False
+        self.mt5_interface.shutdown()
+        self.wait()

src/core/market_profile.py

@@ -0,0 +1,195 @@
+import numpy as np
+import pandas as pd
+from datetime import datetime, time
+
+class MarketProfile:
+    def __init__(self, multiplier=2.0):
+        self.multiplier = multiplier
+        self.counts = {}  # price -> count (time/tick opportunity)
+        self.total_ticks = 0
+        self.min_price = float('inf')
+        self.max_price = float('-inf')
+
+    def reset(self):
+        self.counts = {}
+        self.total_ticks = 0
+        self.min_price = float('inf')
+        self.max_price = float('-inf')
+
+    def fill_gaps(self, prices: np.ndarray, timestamps_ns: np.ndarray, step_sizes: np.ndarray):
+        """
+        Vectorised gap-fill with dynamic step sizes.
+        step_sizes: array of shape (N,) corresponding to each price point.
+                    We use step_sizes[:-1] for the gaps starting at prices[:-1].
+        Returns: (filled_prices, filled_timestamps_ns)
+        """
+        if len(prices) < 2:
+            return prices, timestamps_ns
+
+        # Step sizes for the intervals (from point i -> i+1)
+        # If scalar, broadcast. If array, slice.
+        if np.isscalar(step_sizes):
+            # Broadcast to shape (N-1,)
+            steps_interval = np.full(len(prices)-1, step_sizes, dtype=np.float64)
+        else:
+            # Assume step_sizes corresponds to prices. The step for gap i->i+1 is step_sizes[i].
+            steps_interval = step_sizes[:-1]
+            
+        # Avoid division by zero or extremely small steps
+        steps_interval = np.where(steps_interval < 0.000001, 0.01, steps_interval)
+
+        diff = np.diff(prices)
+        # Number of units (steps) to fill for each gap
+        diff_units = np.round(diff / steps_interval).astype(np.int64)
+        counts = np.abs(diff_units)
+        
+        # Last point gets a count of 1 (itself)
+        counts = np.append(counts, 1)
+
+        total = int(np.sum(counts))
+        if total == 0:
+            return prices, timestamps_ns
+
+        indices = np.repeat(np.arange(len(prices)), counts)
+
+        # Offset within each segment (0, 1, 2...)
+        cum = np.cumsum(counts)
+        starts = np.empty_like(cum)
+        starts[0] = 0
+        starts[1:] = cum[:-1]
+        offsets = np.arange(total) - np.repeat(starts, counts)
+
+        # Direction per segment (+1 or -1)
+        directions = np.zeros(len(prices), dtype=np.float64)
+        directions[:-1] = np.sign(diff_units)
+        
+        # Time step per segment
+        # We need to interpolate time as well
+        dt = np.zeros(len(prices), dtype=np.float64)
+        dt[:-1] = np.diff(timestamps_ns).astype(np.float64)
+        
+        # Avoid division by zero in time steps if counts is 0 (shouldn't happen with counts > 0 check, but be safe)
+        div_counts = np.where(counts > 0, counts, 1)
+        time_steps = dt / div_counts
+
+        # Expand step sizes and time steps
+        if np.isscalar(step_sizes):
+             expanded_steps = np.full(len(indices), step_sizes, dtype=np.float64)
+        else:
+             expanded_steps = step_sizes[indices]
+             
+        expanded_time_steps = time_steps[indices]
+
+        # Calculate filled prices and times
+        filled_prices = prices[indices] + offsets * directions[indices] * expanded_steps
+        filled_ts = timestamps_ns[indices].astype(np.float64) + offsets * expanded_time_steps
+        
+        return np.round(filled_prices, 2), filled_ts.astype(np.int64)
+
+    def update(self, ticks_df: pd.DataFrame):
+        """
+        Updates the profile with new ticks.
+        ticks_df must have 'bid', 'ask', 'datetime'.
+        """
+        if ticks_df.empty:
+            return
+
+        timestamps_ns = ticks_df['datetime'].values.astype('datetime64[ns]').astype(np.int64)
+        bids = ticks_df['bid'].values.astype(np.float64)
+        
+        # Calculate dynamic step sizes based on Spread
+        # Spread = Ask - Bid
+        # Step = Spread * Multiplier
+        
+        # Ensure 'ask' exists
+        if 'ask' in ticks_df.columns:
+            asks = ticks_df['ask'].values.astype(np.float64)
+            spreads = asks - bids
+            # Ensure non-negative/non-zero spread fallback
+            spreads = np.maximum(spreads, 0.00001) 
+            step_sizes = spreads * self.multiplier
+            
+            # Update Bid
+            self.add_data(bids, timestamps_ns, step_sizes)
+            # Update Ask
+            self.add_data(asks, timestamps_ns, step_sizes)
+            
+        else:
+            # Fallback if no ask column
+            step_sizes = np.full(len(bids), 0.01 * self.multiplier)
+            self.add_data(bids, timestamps_ns, step_sizes)
+
+    def add_data(self, prices: np.ndarray, timestamps_ns: np.ndarray, step_sizes: np.ndarray):
+        """
+        Gap-fills the data and updates the histogram counts.
+        """
+        filled_prices, filled_ts = self.fill_gaps(prices, timestamps_ns, step_sizes)
+        
+        # Update histogram
+        unique, counts = np.unique(filled_prices, return_counts=True)
+        
+        for p, c in zip(unique, counts):
+            p = round(float(p), 2)
+            self.counts[p] = self.counts.get(p, 0) + c
+            self.total_ticks += c
+            if p < self.min_price: self.min_price = p
+            if p > self.max_price: self.max_price = p
+
+    def get_vah_val_poc(self):
+        """
+        Calculates Value Area High (VAH), Value Area Low (VAL), and Point of Control (POC).
+        Standard definition: 70% of volume around POC.
+        """
+        if not self.counts:
+            return None, None, None
+
+        # Convert to sorted list of (price, count)
+        sorted_prices = sorted(self.counts.keys())
+        counts_list = [self.counts[p] for p in sorted_prices]
+        
+        counts_array = np.array(counts_list, dtype=np.int64)
+        prices_array = np.array(sorted_prices, dtype=np.float64)
+
+        # POC
+        poc_idx = np.argmax(counts_array)
+        poc_price = prices_array[poc_idx]
+
+        # Value Area (70%)
+        total_count = np.sum(counts_array)
+        target_count = total_count * 0.70
+        
+        current_count = counts_array[poc_idx]
+        left_idx = poc_idx
+        right_idx = poc_idx
+        
+        # Greedily expand
+        while current_count < target_count:
+            # Try to pick best side
+            can_go_left = left_idx > 0
+            can_go_right = right_idx < len(counts_array) - 1
+            
+            if not can_go_left and not can_go_right:
+                break
+            
+            count_left = counts_array[left_idx - 1] if can_go_left else -1
+            count_right = counts_array[right_idx + 1] if can_go_right else -1
+            
+            if count_left > count_right:
+                current_count += count_left
+                left_idx -= 1
+            elif count_right > count_left:
+                current_count += count_right
+                right_idx += 1
+            else:
+                # Equal counts, expand both if possible
+                if can_go_left:
+                    current_count += count_left
+                    left_idx -= 1
+                if can_go_right:
+                    current_count += count_right
+                    right_idx += 1
+
+        val_price = prices_array[left_idx]
+        vah_price = prices_array[right_idx]
+
+        return vah_price, val_price, poc_price

src/core/mt5_interface.py

@@ -0,0 +1,85 @@
+import MetaTrader5 as mt5
+import pandas as pd
+from datetime import datetime, timedelta
+import pytz
+import time
+import src.config as config
+
+class MT5Interface:
+    def __init__(self):
+        self.connected = False
+
+    def initialize(self):
+        """Initializes the connection to MetaTrader 5."""
+        path = getattr(config, 'MT5_PATH', '')
+        login = getattr(config, 'MT5_LOGIN', 0)
+        password = getattr(config, 'MT5_PASSWORD', '')
+        server = getattr(config, 'MT5_SERVER', '')
+
+        if path:
+            if not mt5.initialize(path=path):
+                print(f"MT5 initialize(path={path}) failed, error code = {mt5.last_error()}")
+                self.connected = False
+                return False
+        else:
+            if not mt5.initialize():
+                print(f"MT5 initialize() failed, error code = {mt5.last_error()}")
+                self.connected = False
+                return False
+
+        # Attempt login if credentials provided
+        if login and password and server:
+            authorized = mt5.login(login=login, password=password, server=server)
+            if not authorized:
+                print(f"MT5 login failed, error code = {mt5.last_error()}")
+                mt5.shutdown()
+                self.connected = False
+                return False
+        
+        print("MT5 Initialized successfully.")
+        self.connected = True
+        return True
+
+    def shutdown(self):
+        """Shuts down the connection."""
+        mt5.shutdown()
+        self.connected = False
+
+    def get_ticks(self, symbol, start_time_utc: datetime, end_time_utc: datetime):
+        """
+        Fetches ticks for a given symbol and time range.
+        Returns a DataFrame with 'time_msc', 'bid', 'ask', 'flags', 'volume'.
+        """
+        if not self.connected:
+            if not self.initialize():
+                return pd.DataFrame()
+
+        # Ensure timestamps are timezone-aware (UTC)
+        if start_time_utc.tzinfo is None:
+            start_time_utc = start_time_utc.replace(tzinfo=pytz.utc)
+        if end_time_utc.tzinfo is None:
+            end_time_utc = end_time_utc.replace(tzinfo=pytz.utc)
+
+        ticks = mt5.copy_ticks_range(symbol, start_time_utc, end_time_utc, mt5.COPY_TICKS_ALL)
+        
+        if ticks is None or len(ticks) == 0:
+            print(f"No ticks found for {symbol} between {start_time_utc} and {end_time_utc}")
+            return pd.DataFrame()
+
+        df = pd.DataFrame(ticks)
+        # Convert time_msc to datetime
+        df['datetime'] = pd.to_datetime(df['time_msc'], unit='ms', utc=True)
+        return df
+
+    def get_last_tick(self, symbol):
+        """Fetches the latest tick for the symbol."""
+        if not self.connected:
+            return None
+        
+        tick = mt5.symbol_info_tick(symbol)
+        return tick
+
+    def get_symbol_info(self, symbol):
+        """Returns symbol specification."""
+        info = mt5.symbol_info(symbol)
+        return info

src/main.py

@@ -0,0 +1,24 @@
+import sys
+import os
+
+# Add project root to sys.path to ensure imports work
+# We want the parent of 'src' (project root) in sys.path so 'import src.xxx' works
+current_dir = os.path.dirname(os.path.abspath(__file__))
+project_root = os.path.dirname(current_dir)
+sys.path.append(project_root)
+
+from PyQt6.QtWidgets import QApplication
+from src.ui.main_window import MainWindow
+
+def main():
+    app = QApplication(sys.argv)
+    
+    # Optional: Set a dark theme/palette here
+    
+    window = MainWindow()
+    window.show()
+    
+    sys.exit(app.exec())
+
+if __name__ == "__main__":
+    main()

src/ui/chart_widget.py

@@ -0,0 +1,178 @@
+import pyqtgraph as pg
+from PyQt6.QtWidgets import QWidget, QVBoxLayout
+from PyQt6.QtCore import pyqtSlot
+import numpy as np
+import pandas as pd
+from datetime import datetime
+import pytz
+
+class ChartWidget(QWidget):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.layout = QVBoxLayout()
+        self.setLayout(self.layout)
+        
+        # Initialize PyQtGraph layout
+        self.glw = pg.GraphicsLayoutWidget()
+        self.layout.addWidget(self.glw)
+        
+        # Col 0: Profile (Count vs Price)
+        self.profile_plot = self.glw.addPlot(row=0, col=0)
+        self.profile_plot.setMaximumWidth(200)
+        self.profile_plot.hideAxis('bottom')
+        self.profile_plot.showAxis('top')
+        self.profile_plot.setLabel('top', 'Volume')
+        self.profile_plot.setClipToView(True)
+        # self.profile_plot.setDownsampling(auto=True, mode='peak')
+
+        # Col 1: Price (Time vs Price)
+        self.price_plot = self.glw.addPlot(row=0, col=1)
+        self.price_plot.setLabel('bottom', 'Time')
+        self.price_plot.setLabel('right', 'Price')
+        self.price_plot.showAxis('right')
+        self.price_plot.hideAxis('left')
+        self.price_plot.showAxis('right')
+        self.price_plot.hideAxis('left')
+        self.price_plot.setClipToView(False) # Disable for debugging
+        # self.price_plot.setDownsampling(auto=True, mode='peak') # Disable for debugging
+        
+        # Link Y-axes
+        # self.profile_plot.setYLink(self.price_plot) # temporarily unlink to rule out profile plot issues
+        
+        # Initialize Chart Items
+        self.bid_curve = self.price_plot.plot(pen=pg.mkPen('b', width=1), name="Bid")
+        self.ask_curve = self.price_plot.plot(pen=pg.mkPen('r', width=1), name="Ask")
+        
+        # Profile Histogram Item
+        self.profile_bars = pg.BarGraphItem(x0=0, y=0, width=0, height=0.01, brush='c')
+        self.profile_plot.addItem(self.profile_bars)
+        
+        # Developing Lines (PlotCurveItems)
+        self.curve_vah = self.price_plot.plot(pen=pg.mkPen('g', width=2), name="VAH")
+        self.curve_val = self.price_plot.plot(pen=pg.mkPen('m', width=2), name="VAL")
+        self.curve_poc = self.price_plot.plot(pen=pg.mkPen('y', width=2), name="POC")
+
+        # Date axis formatter
+        self.date_axis = self.price_plot.getAxis('bottom')
+        # self.date_axis.setTickSpacing(3600, 1800) # Grid every hour - Caused MemoryError
+        self.price_plot.showGrid(x=True, y=True, alpha=0.3)
+
+        # Data storage
+        self.times = np.array([])
+        self.bids = np.array([])
+        self.asks = np.array([])
+        
+        # Storage for developing levels
+        self.level_times = np.array([])
+        self.level_vah = np.array([])
+        self.level_val = np.array([])
+        self.level_poc = np.array([])
+
+    def clear(self):
+        self.times = np.array([])
+        self.bids = np.array([])
+        self.asks = np.array([])
+        self.level_times = np.array([])
+        self.level_vah = np.array([])
+        self.level_val = np.array([])
+        self.level_poc = np.array([])
+        
+        self.bid_curve.setData([], [])
+        self.ask_curve.setData([], [])
+        self.profile_bars.setOpts(x0=[], y=[], width=[], height=[])
+        self.curve_vah.setData([], [])
+        self.curve_val.setData([], [])
+        self.curve_poc.setData([], [])
+
+    def update_ticks(self, df):
+        """
+        Updates the tick chart by appending new data.
+        df: DataFrame with 'datetime' (ns timestamp) and 'bid', 'ask'.
+        """
+        if df.empty:
+            return
+
+        # Convert timestamps for pyqtgraph (seconds since epoch)
+        # df['datetime'] is numpy datetime64[ns]
+        new_times = df['datetime'].values.astype(np.float64) / 1e9 
+        new_bids = df['bid'].values
+        new_asks = df['ask'].values if 'ask' in df.columns else np.zeros_like(new_bids)
+        
+        if len(self.times) == 0:
+            self.times = new_times
+            self.bids = new_bids
+            self.asks = new_asks
+        else:
+            self.times = np.concatenate((self.times, new_times))
+            self.bids = np.concatenate((self.bids, new_bids))
+            self.asks = np.concatenate((self.asks, new_asks))
+        
+        # Debug Log
+        if len(self.times) > 0:
+            t_min, t_max = self.times[0], self.times[-1]
+            b_min, b_max = np.min(self.bids), np.max(self.bids)
+            print(f"DEBUG: Chart Ticks: {len(self.times)} pts.")
+            print(f"DEBUG: Time Range: {t_min:.1f} -> {t_max:.1f} ({datetime.fromtimestamp(t_min)} -> {datetime.fromtimestamp(t_max)})")
+            print(f"DEBUG: Price Range: {b_min:.4f} -> {b_max:.4f}")
+        
+        # Update curves
+        self.bid_curve.setData(self.times, self.bids)
+        if len(self.asks) > 0:
+            self.ask_curve.setData(self.times, self.asks)
+        
+        # Force range on first large update
+        if len(self.times) > 0 and len(self.times) == len(new_times): 
+             self.price_plot.setXRange(self.times[0], self.times[-1], padding=0.02)
+             self.price_plot.setYRange(np.min(self.bids), np.max(self.bids), padding=0.02)
+
+    def update_profile(self, counts_dict, unit_size=0.01):
+        """
+        Updates the side profile histogram.
+        counts: dict {price: count}
+        """
+        if not counts_dict:
+            return
+
+        prices = np.array(list(counts_dict.keys()))
+        counts = np.array(list(counts_dict.values()))
+        
+        # Horizontal bars: x0=0, y=prices, width=counts, height=unit_size
+        self.profile_bars.setOpts(x0=np.zeros(len(prices)), y=prices, width=counts, height=unit_size, brush=(0, 255, 255, 100))
+
+    def update_levels(self, new_times, new_vah, new_val, new_poc):
+        """
+        Updates the developing VAH/VAL/POC lines.
+        Expects arrays or scalars.
+        """
+        try:
+            # Ensure inputs are 1D arrays
+            nt = np.atleast_1d(np.array(new_times, dtype=np.float64))
+            nv = np.atleast_1d(np.array(new_vah, dtype=np.float64))
+            nl = np.atleast_1d(np.array(new_val, dtype=np.float64))
+            yp = np.atleast_1d(np.array(new_poc, dtype=np.float64))
+            
+            if len(nt) == 0:
+                # print("Chart Update Levels: Empty new_times")
+                return
+
+            # Append logic
+            if len(self.level_times) == 0:
+                self.level_times = nt
+                self.level_vah = nv
+                self.level_val = nl
+                self.level_poc = yp
+            else:
+                self.level_times = np.concatenate((self.level_times, nt))
+                self.level_vah = np.concatenate((self.level_vah, nv))
+                self.level_val = np.concatenate((self.level_val, nl))
+                self.level_poc = np.concatenate((self.level_poc, yp))
+            
+            if len(nt) > 1:
+                print(f"DEBUG: Chart Levels Loaded: {len(nt)} pts. POC Range: {self.level_poc[0]:.2f} -> {self.level_poc[-1]:.2f}")
+            
+            # Update plots
+            self.curve_vah.setData(self.level_times, self.level_vah)
+            self.curve_val.setData(self.level_times, self.level_val)
+            self.curve_poc.setData(self.level_times, self.level_poc)
+        except Exception as e:
+            print(f"Error updating levels: {e}")

src/ui/control_panel.py

@@ -0,0 +1,78 @@
+from PyQt6.QtWidgets import (
+    QWidget, QVBoxLayout, QLabel, QLineEdit, QDateEdit, 
+    QPushButton, QGroupBox, QFormLayout, QDoubleSpinBox
+)
+from PyQt6.QtCore import QDate, pyqtSignal
+
+class ControlPanel(QWidget):
+    # Signals to notify Main Window
+    # Adjusted to include multiplier
+    start_signal = pyqtSignal(str, object, float) # symbol, date, multiplier
+    stop_signal = pyqtSignal()
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.init_ui()
+
+    def init_ui(self):
+        layout = QVBoxLayout()
+
+        # Group: Settings
+        group = QGroupBox("Settings")
+        form = QFormLayout()
+
+        self.symbol_input = QLineEdit("XAUUSD")
+        
+        self.date_input = QDateEdit()
+        self.date_input.setDate(QDate.currentDate())
+        self.date_input.setCalendarPopup(True)
+
+        self.multiplier_input = QDoubleSpinBox()
+        self.multiplier_input.setRange(0.1, 100.0)
+        self.multiplier_input.setDecimals(2)
+        self.multiplier_input.setValue(2.0)
+        self.multiplier_input.setSingleStep(0.5)
+
+        form.addRow("Symbol:", self.symbol_input)
+        form.addRow("Date:", self.date_input)
+        form.addRow("Spread Multiplier (x):", self.multiplier_input)
+        
+        group.setLayout(form)
+        layout.addWidget(group)
+
+        # Buttons
+        self.btn_start = QPushButton("Start Stream")
+        self.btn_start.clicked.connect(self.on_start)
+        self.btn_start.setStyleSheet("background-color: green; color: white; font-weight: bold;")
+        
+        self.btn_stop = QPushButton("Stop Stream")
+        self.btn_stop.clicked.connect(self.on_stop)
+        self.btn_stop.setStyleSheet("background-color: red; color: white; font-weight: bold;")
+        self.btn_stop.setEnabled(False)
+
+        layout.addWidget(self.btn_start)
+        layout.addWidget(self.btn_stop)
+        
+        layout.addStretch()
+        self.setLayout(layout)
+
+    def on_start(self):
+        symbol = self.symbol_input.text()
+        date = self.date_input.date().toPyDate()
+        multiplier = self.multiplier_input.value()
+        self.start_signal.emit(symbol, date, multiplier)
+        
+        self.btn_start.setEnabled(False)
+        self.btn_stop.setEnabled(True)
+        self.symbol_input.setEnabled(False)
+        self.date_input.setEnabled(False)
+        self.multiplier_input.setEnabled(False)
+
+    def on_stop(self):
+        self.stop_signal.emit()
+        
+        self.btn_start.setEnabled(True)
+        self.btn_stop.setEnabled(False)
+        self.symbol_input.setEnabled(True)
+        self.date_input.setEnabled(True)
+        self.multiplier_input.setEnabled(True)

src/ui/main_window.py

@@ -0,0 +1,96 @@
+from PyQt6.QtWidgets import (
+    QMainWindow, QDockWidget, QStatusBar, QMessageBox, QWidget
+)
+from PyQt6.QtCore import Qt
+
+from src.ui.control_panel import ControlPanel
+from src.ui.chart_widget import ChartWidget
+from src.core.data_worker import DataWorker
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Python Trading Terminal (MT5 + Gap-Filled Profile)")
+        self.resize(1200, 800)
+        
+        self.init_ui()
+        self.worker = None
+
+    def init_ui(self):
+        # Status Bar
+        self.status_bar = QStatusBar()
+        self.setStatusBar(self.status_bar)
+        
+        # Dock: Control Panel
+        self.dock_controls = QDockWidget("Controls", self)
+        self.control_panel = ControlPanel()
+        self.dock_controls.setWidget(self.control_panel)
+        self.dock_controls.setAllowedAreas(Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea)
+        self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, self.dock_controls)
+        
+        # Central: Chart
+        self.chart_widget = ChartWidget()
+        self.setCentralWidget(self.chart_widget)
+        
+        # Connections
+        self.control_panel.start_signal.connect(self.start_worker)
+        self.control_panel.stop_signal.connect(self.stop_worker)
+
+    def start_worker(self, symbol, date, multiplier):
+        if self.worker is not None and self.worker.isRunning():
+            return
+            
+        self.chart_widget.clear()
+        self.chart_widget.price_plot.setTitle(f"{symbol} - {date} (Multiplier: {multiplier}x)")
+        
+        self.worker = DataWorker(symbol, date, multiplier=multiplier)
+        self.worker.status_signal.connect(self.status_bar.showMessage)
+        self.worker.data_signal.connect(self.handle_data)
+        self.worker.levels_signal.connect(self.handle_levels)
+        self.worker.finished.connect(self.on_worker_finished)
+        
+        self.worker.start()
+
+    def stop_worker(self):
+        if self.worker:
+            self.worker.stop()
+            self.worker = None
+            self.status_bar.showMessage("Stream stopped.")
+
+    def handle_data(self, ticks_df, profile_counts):
+        # Update Chart with new ticks
+        # Note: ChartWidget.update_ticks expects a dataframe. 
+        # If we just append, we might need to handle state inside chart widget better.
+        # But simpler: pass the full set or update logic.
+        # For performance, we should probably append.
+        # In current ChartWidget, update_ticks SETS data. 
+        # DataWorker emits chunks (new_ticks) during loop, but FULL history at start.
+        # We need to distinguish or accumulate in ChartWidget?
+        # Actually, DataWorker emits distinct chunks in the loop.
+        # But ChartWidget `setData` replaces content.
+        # We need to accumulate data in ChartWidget or pass accumulated data from Worker.
+        # Passing Full DF every 500ms with millions of rows is bad.
+        # Better: ChartWidget accumulates.
+        
+        # Actually, let's just make ChartWidget append.
+        # Or better: Worker sends everything? No.
+        # Let's Modify ChartWidget to accumulate.
+        
+        # WAIT: My ChartWidget implementation `update_ticks` does: `self.bid_curve.setData(t_float, bids)`
+        # This REPLACES.
+        # I need to fix ChartWidget to handle incremental updates or large data better.
+        # For now, let's just pass the full accumulated history from Worker?
+        # Worker doesn't store accumulated history openly, it just emits `ticks_df` (chunk).
+        # We need a way to append.
+        
+        # Let's fix ChartWidget in next step. For now assume it appends.
+        self.chart_widget.update_ticks(ticks_df)
+        self.chart_widget.update_profile(profile_counts) # Full profile is cheap (dict)
+
+    def handle_levels(self, times, vah, val, poc):
+        self.chart_widget.update_levels(times, vah, val, poc)
+
+    def on_worker_finished(self):
+        self.control_panel.on_stop()
+        self.worker = None
+        self.status_bar.showMessage("Ready.")

tests/test_interactive_chart.py

@@ -0,0 +1,69 @@
+import sys
+import os
+import numpy as np
+import pandas as pd
+from PyQt6.QtWidgets import QApplication
+from PyQt6.QtCore import QTimer
+import pyqtgraph as pg
+
+# Add project root to path
+sys.path.append(os.getcwd())
+
+from src.ui.chart_widget import ChartWidget
+
+def verify_chart_render():
+    app = QApplication(sys.argv)
+    widget = ChartWidget()
+    widget.resize(800, 600)
+    widget.show()
+    
+    print("Widget shown. Generating dummy data...")
+    
+    # 1. Simulate Tick Data
+    now = pd.Timestamp.now()
+    dates = pd.date_range(start=now, periods=100, freq='1s')
+    bids = np.linspace(100, 105, 100) + np.random.normal(0, 0.1, 100)
+    asks = bids + 0.2
+    
+    df = pd.DataFrame({
+        'datetime': dates,
+        'bid': bids,
+        'ask': asks
+    })
+    
+    # Update ticks
+    widget.update_ticks(df)
+    print("Ticks updated.")
+    
+    # Check if curves have data
+    x, y = widget.bid_curve.getData()
+    if x is not None and len(x) == 100:
+        print("PASS: Bid curve has data.")
+    else:
+        print(f"FAIL: Bid curve data mismatch. Len: {len(x) if x is not None else 0}")
+        
+    # 2. Simulate Levels
+    # timestamps for 10 min
+    level_times = [dates[i].timestamp() for i in range(0, 100, 10)]
+    level_vah = np.linspace(101, 104, 10)
+    level_val = np.linspace(99, 102, 10)
+    level_poc = np.linspace(100, 103, 10)
+    
+    widget.update_levels(level_times, level_vah, level_val, level_poc)
+    print("Levels updated.")
+    
+    x_vah, y_vah = widget.curve_vah.getData()
+    if x_vah is not None and len(x_vah) == 10:
+        print("PASS: VAH curve has data.")
+    else:
+        print(f"FAIL: VAH curve data mismatch. Len: {len(x_vah) if x_vah is not None else 0}")
+
+    # Set a timer to close the app automatically after a few seconds if running in automation
+    # QTimer.singleShot(2000, app.quit)
+    
+    # For now, just quit immediately to verify logic
+    app.quit()
+    print("Test finished.")
+
+if __name__ == "__main__":
+    verify_chart_render()

tests/test_logic.py

@@ -0,0 +1,69 @@
+import sys
+import os
+import unittest
+import numpy as np
+import pandas as pd
+
+# Add src to path
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
+from src.core.market_profile import MarketProfile
+
+class TestMarketProfile(unittest.TestCase):
+    def setUp(self):
+        self.mp = MarketProfile(unit_size=1.0) # Simple unit size
+
+    def test_gap_fill(self):
+        prices = np.array([100.0, 105.0])
+        timestamps = np.array([0, 100], dtype=np.int64)
+        
+        filled = self.mp.fill_gaps(prices, timestamps)
+        
+        # Expected: 100, 101, 102, 103, 104, 105
+        expected = np.array([100.0, 101.0, 102.0, 103.0, 104.0, 105.0])
+        
+        np.testing.assert_array_equal(filled, expected)
+
+    def test_profile_calculation(self):
+        # Create a skewed profile
+        # 100: 10 counts
+        # 101: 20 counts (POC)
+        # 102: 5 counts
+        
+        # Construct dataframe
+        data = {
+            'bid': np.concatenate([
+                np.full(10, 100.0),
+                np.full(20, 101.0),
+                np.full(5, 102.0)
+            ]),
+            'datetime': np.zeros(35, dtype='datetime64[ns]') # Timestamps don't matter much for counts
+        }
+        df = pd.DataFrame(data)
+        
+        # Since gap filling needs consecutive diffs, and here we have flat regions,
+        # gap filling on [100, 100] produces just [100, 100].
+        # But `fill_gaps` logic: diff=0 -> count=0 -> total=0?
+        # My implementation: counts = abs(diff) ... append 1 for last point.
+        # If diff=0, count=0. Total = 0 + 1 = 1.
+        # It handles flat lines correctly (just repeats the point).
+        
+        self.mp.update(df)
+        
+        vah, val, poc = self.mp.get_vah_val_poc()
+        
+        self.assertEqual(poc, 101.0)
+        
+        # Total vol = 35. 70% = 24.5.
+        # POC volume = 20.
+        # Neighbors: 100 (10), 102 (5).
+        # 100 is larger. So it should expand to 100.
+        # Current vol = 20 + 10 = 30 > 24.5. Stop.
+        # So Value Area = [100, 101].
+        # VAL = 100, VAH = 101.
+        
+        self.assertEqual(val, 100.0)
+        self.assertEqual(vah, 101.0)
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_profile_logic.py

@@ -0,0 +1,73 @@
+import sys
+import os
+import pandas as pd
+import numpy as np
+
+# Add project root to sys.path
+current_dir = os.path.dirname(os.path.abspath(__file__))
+project_root = os.path.dirname(current_dir)
+sys.path.append(project_root)
+
+from src.core.market_profile import MarketProfile
+
+def test_market_profile_logic():
+    print("Testing Market Profile Logic (Bid + Ask + Timestamp Interpolation)...")
+    
+    # 1. Setup Data
+    # Bid moves from 100.00 to 101.00 (Diff 1.0)
+    # Ask moves from 100.10 to 101.10 (Diff 1.0)
+    # Spread = 0.10
+    # Multiplier = 2.0 -> Bin Size = 0.20
+    
+    # Expected Gaps for Bid: 1.0 / 0.20 = 5 steps.
+    # Bid points: 100.0, 100.2, 100.4, 100.6, 100.8, 101.0 -> 6 points.
+    
+    # Expected Gaps for Ask: 1.0 / 0.20 = 5 steps.
+    # Ask points: 100.1, 100.3, 100.5, 100.7, 100.9, 101.1 -> 6 points.
+    
+    # Total Ticks = 12.
+    
+    multiplier = 2.0
+    
+    data = {
+        'datetime': [pd.Timestamp('2023-01-01 10:00:00'), pd.Timestamp('2023-01-01 10:00:01')],
+        'bid': [100.00, 101.00],
+        'ask': [100.10, 101.10]
+    }
+    df = pd.DataFrame(data)
+    
+    # 2. Initialize Profile
+    mp = MarketProfile(multiplier=multiplier)
+    
+    # 3. Update
+    mp.update(df)
+    
+    # 4. Verify
+    print(f"Total Ticks (Count sum): {mp.total_ticks}") 
+    expected_ticks = 12
+    
+    if mp.total_ticks == expected_ticks:
+        print("SUCCESS: Total Ticks match expected (Bid + Ask filled).")
+    else:
+        print(f"FAILURE: Expected {expected_ticks}, got {mp.total_ticks}")
+    
+    print(f"Counts: {mp.counts}")
+    
+    # Check specific prices
+    expected_bids = [100.00, 100.20, 100.40, 100.60, 100.80, 101.00]
+    expected_asks = [100.10, 100.30, 100.50, 100.70, 100.90, 101.10]
+    all_expected = expected_bids + expected_asks
+    
+    missing = []
+    for p in all_expected:
+        p_rounded = round(p, 2)
+        if p_rounded not in mp.counts:
+            missing.append(p_rounded)
+            
+    if not missing:
+        print("SUCCESS: All expected Bid and Ask gap prices found.")
+    else:
+        print(f"FAILURE: Missing prices: {missing}")
+
+if __name__ == "__main__":
+    test_market_profile_logic()

tests/verify_levels.py

@@ -0,0 +1,44 @@
+import pandas as pd
+import numpy as np
+import sys
+import os
+
+# Add project root to path
+sys.path.append(os.getcwd())
+
+from src.core.market_profile import MarketProfile
+
+def test_market_profile():
+    print("Testing MarketProfile...")
+    mp = MarketProfile(multiplier=2.0)
+    
+    # Create dummy data
+    # Price oscillates between 100 and 110
+    dates = pd.date_range(start='2024-01-01 10:00', periods=100, freq='1min')
+    bids = np.linspace(100, 110, 50)
+    bids = np.concatenate((bids, np.linspace(110, 100, 50)))
+    
+    df = pd.DataFrame({
+        'datetime': dates,
+        'bid': bids,
+        'ask': bids + 0.1
+    })
+    
+    # Update profile
+    mp.update(df)
+    
+    # Check counts
+    print(f"Total ticks: {mp.total_ticks}")
+    print(f"Counts keys: {len(mp.counts)}")
+    
+    # Check Levels
+    vah, val, poc = mp.get_vah_val_poc()
+    print(f"VAH: {vah}, VAL: {val}, POC: {poc}")
+    
+    if vah is None or val is None or poc is None:
+        print("FAIL: Levels are None")
+    else:
+        print("PASS: Levels calculated")
+
+if __name__ == "__main__":
+    test_market_profile()