Zones are tested only when price come into base range after completing entire formation:…
- User
Zones are tested only when price come into base range after completing entire formation: import os from flask import Flask, render_template, request from binance.client import Client from binance.exceptions import BinanceAPIException import pandas as pd import plotly.graph_objs as go from plotly.offline import plot import datetime import time
Initialize the Flask application
app = Flask(name)
Configure Binance Client (No API key needed for public data)
client = Client()
Symbols and Timeframes
symbols = [ 'BTCUSDT', 'ETHUSDT', 'XRPUSDT', 'DOGEUSDT', 'SOLUSDT', 'BNBUSDT', 'SUIUSDT', 'CKBUSDT', 'FTMUSDT', 'RUNEUSDT', 'UNIUSDT', 'AAVEUSDT', 'BCHUSDT', 'KEYUSDT', '1INCHUSDT' ]
timeframes = ['30m', '1h', '2h', '4h']
Rate limit parameters
API_RATE_LIMIT = 150 # Max 150 requests per minute REQUEST_INTERVAL = 60 / API_RATE_LIMIT # Interval between requests
Function to fetch historical candlestick data
def get_historical_klines(symbol, interval, limit=500): try: # Sleep to respect the API rate limit time.sleep(REQUEST_INTERVAL) klines = client.get_klines(symbol=symbol, interval=interval, limit=limit) df = pd.DataFrame(klines, columns=[ 'timestamp', 'open', 'high', 'low', 'close', 'volume', 'close_time', 'quote_asset_volume', 'number_of_trades', 'taker_buy_base', 'taker_buy_quote', 'ignore' ]) df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms') df[['open', 'high', 'low', 'close']] = df[['open', 'high', 'low', 'close']].astype(float) return df except BinanceAPIException as e: print(f"Error fetching data for {symbol}: {e}") return None
Updated function to identify supply zones (DBD and RBD patterns)
def identify_supply_zones(df): supply_zones = []
for i in range(1, len(df) - 1): # Base candle body size body_base = abs(df['close'].iloc[i] - df['open'].iloc[i]) # For DBD Pattern: Drop-Base-Drop body_drop_before = abs(df['close'].iloc[i - 1] - df['open'].iloc[i - 1]) body_drop_after = abs(df['close'].iloc[i + 1] - df['open'].iloc[i + 1]) is_drop_before = df['close'].iloc[i - 1] < df['open'].iloc[i - 1] is_drop_after = df['close'].iloc[i + 1] < df['open'].iloc[i + 1] body_condition = body_drop_before > body_base and body_drop_after > body_base if is_drop_before and is_drop_after and body_condition: # For DBD, consider High of Base Candle Range to Low of Base Body upper_bound = df['high'].iloc[i] lower_bound = min(df['open'].iloc[i], df['close'].iloc[i]) zone = { 'start_time': df['timestamp'].iloc[i], 'end_time': df['timestamp'].iloc[i], 'upper_bound': upper_bound, 'lower_bound': lower_bound, 'type': 'DBD' } supply_zones.append(zone) # For RBD Pattern: Rally-Base-Drop body_rally = abs(df['close'].iloc[i - 1] - df['open'].iloc[i - 1]) body_drop_after = abs(df['close'].iloc[i + 1] - df['open'].iloc[i + 1]) is_rally_before = df['close'].iloc[i - 1] > df['open'].iloc[i - 1] is_drop_after = df['close'].iloc[i + 1] < df['open'].iloc[i + 1] body_condition = body_rally > body_base and body_drop_after > body_base if is_rally_before and is_drop_after and body_condition: # For RBD, use High of formation and Low of Base Body upper_bound = max(df['high'].iloc[i - 1], df['high'].iloc[i], df['high'].iloc[i + 1]) lower_bound = min(df['open'].iloc[i], df['close'].iloc[i]) zone = { 'start_time': df['timestamp'].iloc[i - 1], 'end_time': df['timestamp'].iloc[i + 1], 'upper_bound': upper_bound, 'lower_bound': lower_bound, 'type': 'RBD' } supply_zones.append(zone) return supply_zonesFunction to check if the supply zone is fresh, tested, or violated
def check_zone_freshness(df, zone): zone_df = df[df['timestamp'] > zone['end_time']]
if zone_df.empty: zone['status'] = 'Fresh' return zone # Check if price has re-entered the supply zone reentries = zone_df[ (zone_df['high'] >= zone['lower_bound']) & (zone_df['low'] <= zone['upper_bound']) ] if reentries.empty: zone['status'] = 'Fresh' else: # Check if the zone is still valid (price hasn't closed above the zone) violations = reentries[reentries['close'] > zone['upper_bound']] if not violations.empty: zone['status'] = 'Violated' else: zone['status'] = 'Tested' return zoneFunction to plot the candlestick chart with supply zones
def plot_chart(df, zones, symbol, interval): fig = go.Figure(data=[go.Candlestick( x=df['timestamp'], open=df['open'], high=df['high'], low=df['low'], close=df['close'], name='Candlesticks' )])
# Add supply zones for zone in zones: if zone['status'] == 'Fresh': color = 'red' opacity = 0.2 elif zone['status'] == 'Tested': color = 'orange' opacity = 0.2 else: # Skip violated zones continue fig.add_shape(type='rect', x0=zone['start_time'], y0=zone['lower_bound'], x1=df['timestamp'].iloc[-1], y1=zone['upper_bound'], fillcolor=color, opacity=opacity, line=dict(width=0)) fig.add_annotation( x=zone['start_time'], y=zone['upper_bound'], xref="x", yref="y", text=f"{zone['type']} ({zone['status']})", showarrow=True, arrowhead=1, font=dict(color=color) ) fig.update_layout(title=f"{symbol} - {interval} Chart with Supply Zones", xaxis_title='Time', yaxis_title='Price', xaxis_rangeslider_visible=False) return plot(fig, output_type='div')Define the Flask routes
@app.route('/', methods=['GET']) def index(): return ''' Supply Zone Finder Symbol: ''' + ''.join([f'{s}' for s in symbols]) + ''' Timeframe: ''' + ''.join([f'{t}' for t in timeframes]) + ''' '''
@app.route('/chart', methods=['POST']) def chart(): symbol = request.form['symbol'] interval = request.form['interval'] df = get_historical_klines(symbol, interval, limit=150) # Set limit to 150 if df is not None: zones = identify_supply_zones(df) zones = [check_zone_freshness(df, zone) for zone in zones if zone is not None] # Filter out violated zones zones = [zone for zone in zones if zone['status'] != 'Violated']
# Sort zones by start_time in descending order to get the most recent zones first zones.sort(key=lambda x: x['start_time'], reverse=True) # Get the last 2 Fresh zones fresh_zones = [zone for zone in zones if zone['status'] == 'Fresh'][:2] # Get the last 1 Tested zone tested_zones = [zone for zone in zones if zone['status'] == 'Tested'][:1] # Combine the selected zones selected_zones = fresh_zones + tested_zones chart_div = plot_chart(df, selected_zones, symbol, interval) return f''' <h1>{symbol} - {interval} Chart</h1> {chart_div} <a href="/">Back</a> ''' else: return f''' <h1>Error fetching data for {symbol}</h1> <a href="/">Back</a> '''Run the Flask application
if name == 'main': app.run(debug=True)
- Assistant
It looks like you're working on a Flask application that identifies and visualizes supply zones (DBD and RBD patterns) on cryptocurrency charts using Binance data. Your initial statement indicates that:
Zones are tested only when price comes into base range after completing the entire formation.
From the code you've provided, particularly in the
identify_supply_zonesandcheck_zone_freshnessfunctions, it seems you're aiming to implement this logic. However, there might be some adjustments needed to ensure that zones are classified correctly based on your criteria.Let's delve into your code, analyze the relevant parts, and see how we can align it with your intended logic.
Understanding the Current Logic
identify_supply_zonesFunctionThis function scans through the DataFrame
df, identifying supply zones based on the following patterns:-
Drop-Base-Drop (DBD):
- Prior candle (
i - 1) is a drop (bearish candle). - Current candle (
i) is a base (small body). - Next candle (
i + 1) is a drop (bearish candle).
- Prior candle (
-
Rally-Base-Drop (RBD):
- Prior candle (
i - 1) is a rally (bullish candle). - Current candle (
i) is a base (small body). - Next candle (
i + 1) is a drop (bearish candle).
- Prior candle (
For each identified pattern, a zone is created with
upper_boundandlower_bound, along with thestart_timeandend_timeof the formation.check_zone_freshnessFunctionThis function checks if a supply zone is:
- Fresh: Price has not re-entered the supply zone after its formation.
- Tested: Price has re-entered the supply zone but hasn't closed above it.
- Violated: Price has closed above the supply zone, invalidating it.
Identifying the Issue
Based on your initial statement, it seems you're concerned that the current logic might not be correctly identifying when a zone has been tested. Specifically, you want to ensure:
- A zone should only be marked as 'tested' if the price comes back into the base range after the entire formation (of the supply zone) is complete.
In the current
check_zone_freshnessfunction, the code checks for any re-entries into the zone afterzone['end_time'], without considering whether the re-entry occurred immediately or at some later point.However, the price could re-enter the zone before the entire formation is complete, which might incorrectly classify a zone as 'tested' when it should still be 'fresh'.
Proposed Solution
To align the code with your desired logic, we need to adjust the
check_zone_freshnessfunction to:- Ensure that only re-entries after the entire formation are considered.
- Exclude any candles that are part of the formation itself when checking for re-entries.
Steps to Modify the Logic:
-
Adjust the Timeframe for Re-entry Checks:
- When checking for re-entries, start from the candle after the formation ends.
- For DBD, the formation ends at
i + 1. - For RBD, the formation includes
i - 1,i, andi + 1, so the re-entry check should start fromi + 2.
-
Modify the
check_zone_freshnessFunction:- Add a parameter to indicate the index where the formation ends.
- Use this index to slice the DataFrame
dfwhen checking for re-entries. - Ensure that only candles after the formation are considered.
-
Adjust the Zone Data Structure:
- Include the ending index of the formation in each zone dictionary.
- Use this index in the
check_zone_freshnessfunction.
Implementing the Changes
Step 1: Modify the
identify_supply_zonesFunctionWe need to include the ending index of the formation when creating each zone.
Updated
identify_supply_zonesFunction:def identify_supply_zones(df): supply_zones = [] for i in range(1, len(df) - 1): body_base = abs(df['close'].iloc[i] - df['open'].iloc[i]) # DBD Pattern body_drop_before = abs(df['close'].iloc[i - 1] - df['open'].iloc[i - 1]) body_drop_after = abs(df['close'].iloc[i + 1] - df['open'].iloc[i + 1]) is_drop_before = df['close'].iloc[i - 1] < df['open'].iloc[i - 1] is_drop_after = df['close'].iloc[i + 1] < df['open'].iloc[i + 1] body_condition = body_drop_before > body_base and body_drop_after > body_base if is_drop_before and is_drop_after and body_condition: upper_bound = df['high'].iloc[i] lower_bound = min(df['open'].iloc[i], df['close'].iloc[i]) zone = { 'start_time': df['timestamp'].iloc[i - 1], 'end_time': df['timestamp'].iloc[i + 1], 'upper_bound': upper_bound, 'lower_bound': lower_bound, 'type': 'DBD', 'formation_end_index': i + 1 # Include the index where the formation ends } supply_zones.append(zone) # RBD Pattern body_rally = abs(df['close'].iloc[i - 1] - df['open'].iloc[i - 1]) is_rally_before = df['close'].iloc[i - 1] > df['open'].iloc[i - 1] if is_rally_before and is_drop_after and body_condition: upper_bound = max(df['high'].iloc[i - 1], df['high'].iloc[i], df['high'].iloc[i + 1]) lower_bound = min(df['open'].iloc[i], df['close'].iloc[i]) zone = { 'start_time': df['timestamp'].iloc[i - 1], 'end_time': df['timestamp'].iloc[i + 1], 'upper_bound': upper_bound, 'lower_bound': lower_bound, 'type': 'RBD', 'formation_end_index': i + 1 # For RBD, formation ends at i + 1 } supply_zones.append(zone) return supply_zonesStep 2: Modify the
check_zone_freshnessFunctionAdjust the function to accept the ending index of the formation and use it to slice the DataFrame when checking for re-entries.
Updated
check_zone_freshnessFunction:def check_zone_freshness(df, zone): # Start checking from the candle after the formation ends formation_end_idx = zone['formation_end_index'] zone_df = df.iloc[formation_end_idx + 1:] if zone_df.empty: zone['status'] = 'Fresh' return zone # Check if price has re-entered the supply zone after the formation reentries = zone_df[ (zone_df['high'] >= zone['lower_bound']) & (zone_df['low'] <= zone['upper_bound']) ] if reentries.empty: zone['status'] = 'Fresh' else: # Check if the zone is still valid (price hasn't closed above the zone's upper bound) violations = reentries[reentries['close'] > zone['upper_bound']] if not violations.empty: zone['status'] = 'Violated' else: zone['status'] = 'Tested' return zoneStep 3: Update the Zone Representation in the Plotting Function
The plotting function can remain largely the same, but ensure that
zone['start_time']andzone['end_time']correctly represent the zone's duration.
Testing the Updated Code
With these changes, the code should now:
- Correctly identify when a zone is 'Fresh', 'Tested', or 'Violated' based on whether the price re-enters the zone after the entire formation is complete.
- Exclude any candles that are part of the supply zone formation when checking for re-entries.
Full Updated Code Snippet
Here's the updated code for the relevant functions:
def identify_supply_zones(df): supply_zones = [] for i in range(1, len(df) - 1): body_base = abs(df['close'].iloc[i] - df['open'].iloc[i]) # DBD Pattern body_drop_before = abs(df['close'].iloc[i - 1] - df['open'].iloc[i - 1]) body_drop_after = abs(df['close'].iloc[i + 1] - df['open'].iloc[i + 1]) is_drop_before = df['close'].iloc[i - 1] < df['open'].iloc[i - 1] is_drop_after = df['close'].iloc[i + 1] < df['open'].iloc[i + 1] body_condition = body_drop_before > body_base and body_drop_after > body_base if is_drop_before and is_drop_after and body_condition: upper_bound = df['high'].iloc[i] lower_bound = min(df['open'].iloc[i], df['close'].iloc[i]) zone = { 'start_time': df['timestamp'].iloc[i - 1], 'end_time': df['timestamp'].iloc[i + 1], 'upper_bound': upper_bound, 'lower_bound': lower_bound, 'type': 'DBD', 'formation_end_index': i + 1 } supply_zones.append(zone) # RBD Pattern body_rally = abs(df['close'].iloc[i - 1] - df['open'].iloc[i - 1]) is_rally_before = df['close'].iloc[i - 1] > df['open'].iloc[i - 1] if is_rally_before and is_drop_after and body_condition: upper_bound = max(df['high'].iloc[i - 1], df['high'].iloc[i], df['high'].iloc[i + 1]) lower_bound = min(df['open'].iloc[i], df['close'].iloc[i]) zone = { 'start_time': df['timestamp'].iloc[i - 1], 'end_time': df['timestamp'].iloc[i + 1], 'upper_bound': upper_bound, 'lower_bound': lower_bound, 'type': 'RBD', 'formation_end_index': i + 1 } supply_zones.append(zone) return supply_zones def check_zone_freshness(df, zone): # Start checking from the candle after the formation ends formation_end_idx = zone['formation_end_index'] zone_df = df.iloc[formation_end_idx + 1:] if zone_df.empty: zone['status'] = 'Fresh' return zone # Check if price has re-entered the supply zone after formation reentries = zone_df[ (zone_df['high'] >= zone['lower_bound']) & (zone_df['low'] <= zone['upper_bound']) ] if reentries.empty: zone['status'] = 'Fresh' else: # Check if the zone is still valid (price hasn't closed above the zone's upper bound) violations = reentries[reentries['close'] > zone['upper_bound']] if not violations.empty: zone['status'] = 'Violated' else: zone['status'] = 'Tested' return zone
Verifying the Changes
It's crucial to verify that these modifications achieve the intended behavior:
- Zones are only considered 'tested' if the price re-enters the zone after the entire formation is complete.
How to Test:
-
Run the Application:
- Ensure the Flask app runs without errors.
-
Select a Symbol and Timeframe:
- Use known data where you can verify the patterns manually.
-
Check the Output:
- Verify that zones are correctly marked as 'Fresh', 'Tested', or 'Violated' based on the new logic.
- Ensure that zones are not incorrectly classified due to price movements during the formation.
-
Compare with Visual Inspection:
- Visually inspect the chart to confirm that the classification aligns with the price action.
Additional Suggestions
-
Optimize Zone Detection:
- Consider adding more robust pattern recognition to account for varying market conditions.
- Include logic to handle doji candles or small-bodied candles that may affect the pattern.
-
Enhance Visualization:
- Differentiate between 'Fresh' and 'Tested' zones with distinct colors or patterns.
- Add interactive features to hover over zones and see details.
-
Error Handling:
- Include exception handling for any potential data retrieval issues.
- Ensure that the app provides user-friendly error messages.
Conclusion
By adjusting the
identify_supply_zonesandcheck_zone_freshnessfunctions as shown, your application should now correctly identify and classify supply zones based on your specified criteria.Feel free to integrate these changes and test them thoroughly. Let me know if you have any questions or need further assistance!
-