Current Price on Price line and Candles rendering.

[kumarangp]

Hi, I have 2 questions from your complicated.py

#1. Can we add current price of sympol in price line.(see the red arrow in the screen shot)

#2. Candles are not properly rendered at the beginning and change between different periods.(see video capture)
https://gyazo.com/09dbc08457ec3845d0df63f7b66421f7

[someshwaru]

I did like this
def create_price_line_and_label(symbol, ltp, color, position=0.5):
"""Creates a price line and label for the chart."""
try:
# Ensure ltp is a float
ltp = float(ltp)

        # Create an InfiniteLine at the given position
        ltp_line = pg.InfiniteLine(pos=ltp, angle=0, pen=pg.mkPen(color=color, width=1), movable=False)
        ltp_line.addMarker('v', position=1, size=15.0)

        # Create the label for the line and align it in the middle
        ltp_line.label = pg.InfLineLabel(ltp_line, f'LTP @ {ltp:.2f}', position=position, color=color)
        # Customize the label with CSS for bold text and centered alignment
        label_text = (
            f"<div style='background-color: blue; color: white; padding: 2px; "
            f"text-align: center; font-weight: bold; font-size: 16px;'>LTP @ {ltp:.2f}</div>"
        )
        ltp_line.label.setHtml(label_text)
        return ltp_line , ltp_line.label

    except ValueError as e:
        print(f"Error creating LTP line or label: {e}")
        return None 

[kumarangp]

@someshwaru Its working, Thanks for help.
Can you please look into my second concern. candles rendering issue across time frames.
Candle width changing when switch between different time frames.

[someshwaru]

you may be missing fplt.refresh() in change_asset() or post your code .

[kumarangp]

@someshwaru Please look my code and try to solve
Candlestick size are changing while switching time frame.(see video capture). It will be good candles size should be same when switching between different time frame(like trading view)
https://gyazo.com/09dbc08457ec3845d0df63f7b66421f7

import finplot as fplt
from functools import lru_cache
import json
# from math import nan

# import ltp
import pandas as pd
from PyQt6.QtWidgets import QComboBox, QCheckBox, QWidget, QGridLayout
import pyqtgraph as pg
import requests
from time import time as now, sleep
from threading import Thread
import websocket

class BinanceWebsocket:
    def __init__(self):
        self.url = 'wss://stream.binance.com/stream'
        self.symbol = None
        self.interval = None
        self.ws = None
        self.df = None

    def reconnect(self, symbol, interval, df):
        '''Connect and subscribe, if not already done so.'''
        self.df = df
        if symbol.lower() == self.symbol and self.interval == interval:
            return
        self.symbol = symbol.lower()
        self.interval = interval
        self.thread_connect = Thread(target=self._thread_connect)
        self.thread_connect.daemon = True
        self.thread_connect.start()

    def close(self, reset_symbol=True):
        if reset_symbol:
            self.symbol = None
        if self.ws:
            self.ws.close()
        self.ws = None

    def _thread_connect(self):
        self.close(reset_symbol=False)
        print('websocket connecting to %s...' % self.url)
        self.ws = websocket.WebSocketApp(self.url, on_message=self.on_message, on_error=self.on_error)
        self.thread_io = Thread(target=self.ws.run_forever)
        self.thread_io.daemon = True
        self.thread_io.start()
        for _ in range(100):
            if self.ws.sock and self.ws.sock.connected:
                break
            sleep(0.1)
        else:
            self.close()
            raise websocket.WebSocketTimeoutException('websocket connection failed')
        self.subscribe(self.symbol, self.interval)
        print('websocket connected')

    def subscribe(self, symbol, interval):
        try:
            data = '{"method":"SUBSCRIBE","params":["%s@kline_%s"],"id":1}' % (symbol, interval)
            self.ws.send(data)
        except Exception as e:
            print('websocket subscribe error:', type(e), e)
            raise e

    def on_message(self, *args, **kwargs):
        df = self.df
        if df is None:
            return
        msg = json.loads(args[-1])
        if 'stream' not in msg:
            return
        stream = msg['stream']
        if '@kline_' in stream:
            k = msg['data']['k']
            t = k['t']
            t1 = int(df.index[-1].timestamp()) * 1000
            if t <= t1:
                # update last candle
                i = df.index[-1]
                df.loc[i, 'Close']  = float(k['c'])
                df.loc[i, 'High']   = max(df.loc[i, 'High'], float(k['h']))
                df.loc[i, 'Low']    = min(df.loc[i, 'Low'],  float(k['l']))
                df.loc[i, 'Volume'] = float(k['v'])
                print(k)
            else:
                # create a new candle
                data = [t] + [float(k[i]) for i in ['o','c','h','l','v']]
                candle = pd.DataFrame([data], columns='Time Open Close High Low Volume'.split()).astype({'Time':'datetime64[ms]'})
                candle.set_index('Time', inplace=True)
                self.df = pd.concat([df, candle])

    def on_error(self, error, *args, **kwargs):
        print('websocket error: %s' % error)



def do_load_price_history(symbol, interval):
    url = 'https://www.binance.com/api/v1/klines?symbol=%s&interval=%s&limit=%s' % (symbol, interval, 1000)
    print('loading binance %s %s' % (symbol, interval))
    d = requests.get(url).json()
    df = pd.DataFrame(d, columns='Time Open High Low Close Volume a b c d e f'.split())
    df = df.astype({'Time':'datetime64[ms]', 'Open':float, 'High':float, 'Low':float, 'Close':float, 'Volume':float})
    return df.set_index('Time')

@lru_cache(maxsize=5)
def cache_load_price_history(symbol, interval):
    '''Stupid caching, but works sometimes.'''
    return do_load_price_history(symbol, interval)

def load_price_history(symbol, interval):
    '''Use memoized, and if too old simply load the data.'''
    df = cache_load_price_history(symbol, interval)
    # check if cache's newest candle is current
    t0 = df.index[-2].timestamp()
    t1 = df.index[-1].timestamp()
    t2 = t1 + (t1 - t0)
    if now() >= t2:
        df = do_load_price_history(symbol, interval)
    return df

def calc_plot_data(df, indicators):
    '''Returns data for all plots and for the price line.'''
    price = df['Open Close High Low'.split()]
    plot_data = dict(price=price)
    last_close = price.iloc[-1].Close
    last_col = fplt.candle_bull_color if last_close > price.iloc[-2].Close else fplt.candle_bear_color
    price_data = dict(last_close=last_close, last_col=last_col)
    return plot_data, price_data

def realtime_update_plot():
    '''Called at regular intervals by a timer.'''
    if ws.df is None:
        return

    # calculate the new plot data
    indicators = ctrl_panel.indicators.currentText().lower()
    data, price_data = calc_plot_data(ws.df, indicators)

    # first update all data, then graphics (for zoom rigidity)
    for k in data:
        if data[k] is not None:
            plots[k].update_data(data[k], gfx=False)
    for k in data:
        if data[k] is not None:
            plots[k].update_gfx()

    # Remove old price line and label if they exist
    if hasattr(ax, 'ltp_line'):
        ax.removeItem(ax.ltp_line)

    # Create new price line with label
    last_price = price_data['last_close']
    color = price_data['last_col']
    ax.ltp_line, label = create_price_line_and_label(
        ctrl_panel.symbol.currentText(),
        last_price,
        color,
        position=0.8  # Adjust position as needed
    )

    if ax.ltp_line:
        ax.addItem(ax.ltp_line, ignoreBounds=True)

def change_asset(*args, **kwargs):
    '''Resets and recalculates everything, and plots for the first time.'''
    # save window zoom position before resetting
    fplt._savewindata(fplt.windows[0])

    symbol = ctrl_panel.symbol.currentText()
    interval = ctrl_panel.interval.currentText()
    ws.close()
    ws.df = None
    df = load_price_history(symbol, interval=interval)
    ws.reconnect(symbol, interval, df)

    # remove any previous plots
    ax.reset()
    axo.reset()
    ax_rsi.reset()

    # calculate plot data
    indicators = ctrl_panel.indicators.currentText().lower()
    data, price_data = calc_plot_data(df, indicators)

    # some space for legend
    ctrl_panel.move(100 if 'clean' in indicators else 200, 0)

    # plot data
    global plots
    plots = {}
    plots['price'] = fplt.candlestick_ochl(data['price'], ax=ax)
    ax.set_visible(xaxis=True)

    # Initial price line with label
    last_price = price_data['last_close']
    color = price_data['last_col']
    ax.ltp_line, label = create_price_line_and_label(
        symbol,
        last_price,
        color,
        position=0.8  # Adjust position as needed
    )

    if ax.ltp_line:
        ax.addItem(ax.ltp_line, ignoreBounds=True)

    # restores saved zoom position, if in range
    fplt.refresh()

def dark_mode_toggle(dark):
    '''Digs into the internals of finplot and pyqtgraph to change the colors of existing
       plots, axes, backgronds, etc.'''
    # first set the colors we'll be using
    if dark:
        fplt.foreground = '#777'
        fplt.background = '#090c0e'
        fplt.candle_bull_color = fplt.candle_bull_body_color = '#0b0'
        fplt.candle_bear_color = '#a23'
        volume_transparency = '6'
    else:
        fplt.foreground = '#444'
        fplt.background = fplt.candle_bull_body_color = '#fff'
        fplt.candle_bull_color = '#380'
        fplt.candle_bear_color = '#c50'
        volume_transparency = 'c'
    fplt.volume_bull_color = fplt.volume_bull_body_color = fplt.candle_bull_color + volume_transparency
    fplt.volume_bear_color = fplt.candle_bear_color + volume_transparency
    fplt.cross_hair_color = fplt.foreground+'8'
    fplt.draw_line_color = '#888'
    fplt.draw_done_color = '#555'

    pg.setConfigOptions(foreground=fplt.foreground, background=fplt.background)
    # control panel color
    if ctrl_panel is not None:
        p = ctrl_panel.palette()
        p.setColor(ctrl_panel.darkmode.foregroundRole(), pg.mkColor(fplt.foreground))
        ctrl_panel.darkmode.setPalette(p)

    # window background
    for win in fplt.windows:
        win.setBackground(fplt.background)

    # axis, crosshair, candlesticks, volumes
    axs = [ax for win in fplt.windows for ax in win.axs]
    vbs = set([ax.vb for ax in axs])
    axs += fplt.overlay_axs
    axis_pen = fplt._makepen(color=fplt.foreground)
    for ax in axs:
        ax.axes['right']['item'].setPen(axis_pen)
        ax.axes['right']['item'].setTextPen(axis_pen)
        ax.axes['bottom']['item'].setPen(axis_pen)
        ax.axes['bottom']['item'].setTextPen(axis_pen)
        if ax.crosshair is not None:
            ax.crosshair.vline.pen.setColor(pg.mkColor(fplt.foreground))
            ax.crosshair.hline.pen.setColor(pg.mkColor(fplt.foreground))
            ax.crosshair.xtext.setColor(fplt.foreground)
            ax.crosshair.ytext.setColor(fplt.foreground)
        for item in ax.items:
            if isinstance(item, fplt.FinPlotItem):
                isvolume = ax in fplt.overlay_axs
                if not isvolume:
                    item.colors.update(
                        dict(bull_shadow      = fplt.candle_bull_color,
                             bull_frame       = fplt.candle_bull_color,
                             bull_body        = fplt.candle_bull_body_color,
                             bear_shadow      = fplt.candle_bear_color,
                             bear_frame       = fplt.candle_bear_color,
                             bear_body        = fplt.candle_bear_color))
                else:
                    item.colors.update(
                        dict(bull_frame       = fplt.volume_bull_color,
                             bull_body        = fplt.volume_bull_body_color,
                             bear_frame       = fplt.volume_bear_color,
                             bear_body        = fplt.volume_bear_color))
                item.repaint()

def create_ctrl_panel(win):
    panel = QWidget(win)
    panel.move(100, 0)
    win.scene().addWidget(panel)
    layout = QGridLayout(panel)

    panel.symbol = QComboBox(panel)
    [panel.symbol.addItem(i+'USDT') for i in 'BTC ETH XRP DOGE BNB SOL ADA LTC LINK DOT TRX BCH'.split()]
    panel.symbol.setCurrentIndex(1)
    layout.addWidget(panel.symbol, 0, 0)
    panel.symbol.currentTextChanged.connect(change_asset)

    layout.setColumnMinimumWidth(1, 30)

    panel.interval = QComboBox(panel)
    [panel.interval.addItem(i) for i in '1d 4h 1h 30m 15m 5m 1m 1s'.split()]
    panel.interval.setCurrentIndex(6)
    layout.addWidget(panel.interval, 0, 2)
    panel.interval.currentTextChanged.connect(change_asset)

    layout.setColumnMinimumWidth(3, 30)

    panel.indicators = QComboBox(panel)
    [panel.indicators.addItem(i) for i in 'Clean:Few indicators:Moar indicators'.split(':')]
    panel.indicators.setCurrentIndex(1)
    layout.addWidget(panel.indicators, 0, 4)
    panel.indicators.currentTextChanged.connect(change_asset)

    layout.setColumnMinimumWidth(5, 30)

    panel.darkmode = QCheckBox(panel)
    panel.darkmode.setText('Haxxor mode')
    panel.darkmode.setCheckState(pg.Qt.QtCore.Qt.CheckState.Checked)
    panel.darkmode.toggled.connect(dark_mode_toggle)
    layout.addWidget(panel.darkmode, 0, 6)

    return panel

def create_price_line_and_label(symbol, ltp, color, position=0.5):
    try:
        ltp = float(ltp)
        # Create an InfiniteLine at the given position
        ltp_line = pg.InfiniteLine(pos=ltp, angle=0, pen=pg.mkPen(color=color, width=1), movable=False)
        ltp_line.addMarker('v', position=1, size=15.0)

        # Create the label for the line and align it in the middle
        ltp_line.label = pg.InfLineLabel(ltp_line, f'LTP @ {ltp:.2f}', position=position, color=color)
        # Customize the label with CSS for bold text and centered alignment
        label_text = (
            f"<div style='background-color: blue; color: white; padding: 2px; "
            f"text-align: center; font-weight: bold; font-size: 16px;'>LTP @ {ltp:.2f}</div>"
        )
        ltp_line.label.setHtml(label_text)
        return ltp_line, ltp_line.label
    except ValueError as e:
        print(f"Error creating LTP line or label: {e}")
        return None


plots = {}
fplt.y_pad = 0.07 # pad some extra (for control panel)
fplt.max_zoom_points = 7
fplt.autoviewrestore()
ax,ax_rsi = fplt.create_plot('Complicated Binance Example', rows=2, init_zoom_periods=300)
axo = ax.overlay()

# use websocket for real-time
ws = BinanceWebsocket()

# hide rsi chart to begin with; show x-axis of top plot
ax_rsi.hide()
ax_rsi.vb.setBackgroundColor(None) # don't use odd background color
ax.set_visible(xaxis=True)

ctrl_panel = create_ctrl_panel(ax.vb.win)
dark_mode_toggle(True)
change_asset()
fplt.timer_callback(realtime_update_plot, 0.5) # update twice every second
fplt.show()

[someshwaru]

fplt.max_zoom_points = 10
fplt.right_margin_candles = 30 # space between latest candle and right border

fplt.autoviewrestore() comment this line if needed

[highfestiva]

Answer for your second question: the candles are rendering correctly, but the time frame used is the same when switching between the two resolutions. What you might want is to change the start time when switching candle resolution. Don't know off the top of my head how to do that, you'll have to look it up yourself.