import gradio as gr import requests import pandas as pd import math import os import matplotlib.pyplot as plt from alpha_vantage.timeseries import TimeSeries #symbol = 'NRDS' #target_profit_price = 9.34 #interval = 'daily' # Specify the desired interval ('intraday', 'daily', 'weekly') #start_date = '2023-01-01' # Specify the start date for historical data #buy_signal = False def get_current_stock_price(api_key, symbol): url = f"https://finnhub.io/api/v1/quote?symbol={symbol}&token={api_key}" response = requests.get(url) print(response) data = response.json() return data['c'] # Current price finnhub_api_key=os.environ['FINHUB_API_KEY'] def calculate_fibonacci_retracements(high, low): # Adjust the Fibonacci ratios as needed fibonacci_ratios = [0.236, 0.382, 0.5, 0.618, 0.786] # Example adjusted ratios fibonacci_retracements = [] for i in range(40): fibonacci_level = round((i+1)/(len(fibonacci_ratios)+1), 2) * fibonacci_ratios[i % len(fibonacci_ratios)] fibonacci_retracements.append(fibonacci_level) fibonacci_levels = {} for r in fibonacci_retracements: fibonacci_levels[f"{r * 100:.0f}%"] = round((low + high) - ((high - low) * r), 2) return fibonacci_levels from alpha_vantage.timeseries import TimeSeries def fetch_historical_data(symbol, interval, output_size='compact', start_date=None): # Replace with your AlphaVantage API key api_key = os.environ['ALPHA_VANTAGE_API_KEY'] # Initialize the TimeSeries object ts = TimeSeries(key=api_key, output_format='json') # Map interval to the corresponding AlphaVantage function name interval_mapping = { 'intraday': 'TIME_SERIES_INTRADAY', 'daily': 'TIME_SERIES_DAILY', 'weekly': 'TIME_SERIES_WEEKLY' } if interval not in interval_mapping: raise ValueError("Invalid interval. Supported intervals: 'intraday', 'daily', 'weekly'") # Define the function name based on the interval function_name = interval_mapping[interval] if interval == 'intraday': # Adjust the interval as needed interval = '5min' # Fetch historical data if interval == 'daily': historical_data, meta_data = ts.get_daily_adjusted(symbol=symbol, outputsize=output_size) elif interval == 'weekly': historical_data, meta_data = ts.get_weekly_adjusted(symbol=symbol) else: # For intraday, you can specify the interval (e.g., '5min') historical_data, meta_data = ts.get_intraday(symbol=symbol, interval=interval, outputsize=output_size) return historical_data import numpy as np def calculate_support_resistance_levels(symbol, interval='intraday', output_size='compact'): # Fetch historical price data from AlphaVantage historical_data = fetch_historical_data(symbol, interval, output_size) # Extract closing prices from historical data closing_prices = [float(data['4. close']) for data in historical_data.values()] print("Display historyical data") print(closing_prices) # Calculate moving averages (e.g., 50-day and 200-day) moving_average_50 = np.mean(closing_prices[-50:]) moving_average_200 = np.mean(closing_prices[-200:]) # Calculate support and resistance levels # You can customize your logic for defining these levels based on moving averages # For example, support could be defined as the 50-day moving average, and resistance could be the 200-day moving average support_level = moving_average_50 resistance_level = moving_average_200 return support_level, resistance_level def calculate_entry_exit_points(symbol, target_profit_price, risk_percentage, account_balance, start_date, buy_signal_str): # Convert string inputs to correct data types print("Debugging information:") print("target_profit_price:", target_profit_price) print("risk_percentage:", risk_percentage) print("account_balance:", account_balance) current_price = get_current_stock_price(finnhub_api_key, symbol) print("current_price:", current_price) target_profit_price = float(target_profit_price) risk_percentage = float(risk_percentage) account_balance = float(account_balance) buy_signal = buy_signal_str == "Buy" print("buy_signal:", buy_signal) # Fetch swing high and swing low using symbol, interval, and start date swing_high, swing_low = get_swing_high_low(symbol, 'intraday', start_date) # Calculate Fibonacci levels fibonacci_levels = calculate_fibonacci_retracements(swing_high, swing_low) # Calculate support and resistance levels support_level, resistance_level = calculate_support_resistance_levels(symbol, 'intraday', start_date) # Calculate entry and stop loss based on support and resistance entry_point, stop_loss = calculate_entry_stop_loss(support_level, resistance_level, buy_signal) # Calculate position size based on risk percentage and account balance position_size = (risk_percentage / 100) * account_balance # Calculate take profit based on Fibonacci levels and target price take_profit, closest_levels = calculate_take_profit(target_profit_price, fibonacci_levels, buy_signal) # Calculate profit in dollars for take profit and stop loss if buy_signal: profit_take_profit = (take_profit - entry_point) * position_size profit_stop_loss = (entry_point - stop_loss) * position_size else: profit_take_profit = (entry_point - take_profit) * position_size profit_stop_loss = (stop_loss - entry_point) * position_size # Determine buy/sell flag buy_sell_flag = "Buy" if buy_signal else "Sell" return { 'Ticker': symbol, 'entry': entry_point, 'stop_loss': stop_loss, 'take_profit': take_profit, 'swing_high': swing_high, 'swing_low': swing_low, 'position_size': position_size, 'profit_take_profit': profit_take_profit, 'profit_stop_loss': profit_stop_loss, 'fibonacci_levels': fibonacci_levels, 'closest_levels': closest_levels, 'support_level': support_level, 'resistance_level': resistance_level, 'buy_sell_flag': buy_sell_flag } # Note: You would also need to adjust or create the calculate_profit function to handle profit calculation. def calculate_entry_stop_loss(support_level, resistance_level, buy_signal): # Calculate entry and stop loss based on support and resistance if buy_signal: entry_point = support_level stop_loss = entry_point - (entry_point * 0.02) # Adjust the percentage as needed else: entry_point = resistance_level stop_loss = entry_point + (entry_point * 0.02) # Adjust the percentage as needed return entry_point, stop_loss def calculate_take_profit(target_price, fibonacci_levels, buy_signal): # Calculate take profit based on Fibonacci levels and target price if buy_signal: closest_levels = {k: v for k, v in fibonacci_levels.items() if v > target_price} print("Closest Levels:") print(closest_levels) take_profit_fibonacci_level = max(closest_levels.keys()) take_profit = closest_levels[take_profit_fibonacci_level] else: closest_levels = {k: v for k, v in fibonacci_levels.items() if v < target_price} print("Closest Levels:") print(closest_levels) if closest_levels: take_profit_fibonacci_level = min(closest_levels.keys()) take_profit = closest_levels[take_profit_fibonacci_level] else: take_profit_fibonacci_level = 0 take_profit = 0 # Assuming default level and price return take_profit, closest_levels def get_swing_high_low(symbol, interval, start_date): print(symbol, interval, start_date) # Fetch historical price data from AlphaVantage historical_data = fetch_historical_data(symbol,interval, start_date=start_date) print("prining historical data") print(historical_data) # Initialize variables to store swing high and swing low prices swing_high = None swing_low = None # Iterate through historical data to find swing high and swing low for date, price_data in historical_data.items(): high_price = float(price_data['2. high']) low_price = float(price_data['3. low']) if swing_high is None or high_price > swing_high: swing_high = high_price if swing_low is None or low_price < swing_low: swing_low = low_price return swing_high, swing_low import gradio as gr def interface_wrapper(symbol, target_profit_price, risk_percentage, account_balance, start_date, buy_signal): # Your function logic here # Dummy return for demonstration purposes return { "Entry Point": 100, "Stop Loss": 90, "Take Profit": 110, "Position Size": 1000, "Profit (Take Profit)": 100, "Profit (Stop Loss)": -100, "Fibonacci Levels": {"38.2%": 95, "61.8%": 105}, "Buy/Sell Flag": buy_signal } # Ensure inputs to Gradio interface are in the correct order and use the correct components demo = gr.Interface( fn=calculate_entry_exit_points, inputs=[ gr.Textbox(label="Stock Symbol"), # symbol gr.Number(label="Target Profit Price"), # target_profit_price gr.Slider(label="Risk Percentage", minimum=0, maximum=100, step=0.1), # risk_percentage, with default at 2% gr.Number(label="Account Balance"), # account_balance, with default gr.Textbox(label="Start Date", placeholder="YYYY-MM-DD"), # start_date, with default gr.Radio(choices=["Buy", "Sell"], label="Buy/Sell Signal") # buy_signal, with default ], outputs=gr.JSON(label="Results"), description="Enter the necessary information to calculate entry and exit points for stock trading." ) demo.launch(share=True) # share=True to create a public link def plot_trade(entry, stop_loss, take_profit, fibonacci_json): # Parse the Fibonacci levels from JSON fibonacci_levels = json.loads(fibonacci_json) # Prepare data for plotting fib_levels = list(fibonacci_levels.values()) fib_labels = list(fibonacci_levels.keys()) # Initialize the plot plt.figure(figsize=(10, 6)) plt.title("Trade Setup with Fibonacci Levels") # Plot Fibonacci levels for i, level in enumerate(fib_levels): plt.axhline(y=level, linestyle='--', color='gray', alpha=0.5) plt.text(len(fib_labels) + 1, level, f"{fib_labels[i]}: {level}", verticalalignment='center') # Plot entry, stop_loss, and take_profit plt.axhline(y=entry, color='blue', label='Entry') plt.axhline(y=stop_loss, color='red', label='Stop Loss') plt.axhline(y=take_profit, color='green', label='Take Profit') plt.legend() plt.xlabel("Fibonacci Levels") plt.ylabel("Price") plt.tight_layout() # Save the plot to a temporary file and return its path plt_path = "/mnt/data/trade_setup.png" plt.savefig(plt_path) plt.close() return plt_path # Example usage #current_price = get_current_stock_price(finnhub_api_key, symbol) # start_date = '2023-01-01' # swing_high, swing_low = get_swing_high_low(symbol, 'weekly', start_date) # print(f"Swing High: {swing_high}, Swing Low: {swing_low}") # risk_percentage = 1finnhub_api_key # account_balance = 10000 # entry_exit_points = calculate_entry_exit_points(current_price=current_price, target_price=target_profit_price, risk_percentage=1, account_balance=10000, swing_high=swing_high, swing_low=swing_low,buy_signal=buy_signal) # Printing the output # print("Current Price:", current_price) # print("Price Target:", target_profit_price) # print("Entry Price:", entry_exit_points['entry']) # print("Stop Loss:", entry_exit_points['stop_loss']) # print("Take Profit:", entry_exit_points['take_profit']) # print("Position Size:", entry_exit_points['position_size']) # print("Profit (Take Profit): $", entry_exit_points['profit_take_profit']) # print("Profit (Stop Loss): $", entry_exit_points['profit_stop_loss']) # print("Fibonacci Levels:", entry_exit_points['fibonacci_levels']) # Print the closest levels and their associated prices for debugging # if buy_signal: # print(f"Closest levels for Buy (targeting {target_profit_price}): {entry_exit_points['closest_levels']}") # else: # print(f"Closest levels for Sell (targeting {target_profit_price}): {entry_exit_points['closest_levels']}") # print("Buy/Sell Flag:", entry_exit_points['buy_sell_flag']) # Print the structure of entry_exit_points['closest_levels'] # Extract levels and prices from entry_exit_points['closest_levels'] dictionary # levels = list(entry_exit_points['closest_levels'].keys()) # prices = list(entry_exit_points['closest_levels'].values()) # Create a bar chart # plt.figure(figsize=(10, 6)) # plt.bar(levels, prices, color='blue' if buy_signal else 'red') # plt.xlabel("Fibonacci Levels") # plt.ylabel("Price") # plt.title("Average Price at Fibonacci Levels") # plt.xticks(rotation=45) # Show the chart # plt.show() # print(entry_exit_points['closest_levels']) # for key, value in entry_exit_points['closest_levels'].items(): # print(f"Property: {key}, Value: {value}") # Check if it's a buy or sell signal and adjust the title accordingly # if buy_signal: # title = f"Closest Levels for Buy (targeting {target_profit_price})" # else: # title = f"Closest Levels for Sell (targeting {target_profit_price})"