import` pandas as pd
import mplfinance as mpf
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
import tkinter as tk
from tkinter import ttk
import os
import matplotlib.pyplot as plt
df_bourse = pd.DataFrame([
 {'Année': 2022, 'Période': 'Été US', 'Début': '2022-03-14', 'Fin': '2022-03-28', 'Modedate': 1},
 {'Année': 2022, 'Période': 'Hiver US', 'Début': '2022-10-31', 'Fin': '2022-11-04', 'Modedate': 1},
 {'Année': 2023, 'Période': 'Été US', 'Début': '2023-03-13', 'Fin': '2023-03-24', 'Modedate': 1},
 {'Année': 2023, 'Période': 'Hiver US', 'Début': '2023-10-30', 'Fin': '2023-11-03', 'Modedate': 1},
 {'Année': 2024, 'Période': 'Été US', 'Début': '2024-03-11', 'Fin': '2024-03-28', 'Modedate': 1},
 {'Année': 2024, 'Période': 'Hiver US', 'Début': '2024-10-28', 'Fin': '2024-11-01', 'Modedate': 1}
])
df_bourse['Début'] = pd.to_datetime(df_bourse['Début'])
df_bourse['Fin'] = pd.to_datetime(df_bourse['Fin'])
csv_path = r"C:\Formation Python\FX_NAS100, 5.csv"
df = pd.read_csv(csv_path)
csv_filename = os.path.basename(csv_path)
df["time"] = pd.to_datetime(df["time"], unit='s')
df['date'] = df['time'].dt.date
def determine_modedate(date):
 for _, row in df_bourse.iterrows():
 if row['Début'].date() <= date <= row['Fin'].date():
 return row['Modedate']
 return 2
df['Modedate'] = df['date'].apply(determine_modedate)
df['amp_journée'] = 0.0
for day in df['date'].unique():
 day_data = df[df['date'] == day]
 if not day_data.empty:
 modedate = day_data['Modedate'].iloc[0]
 if modedate == 1:
 start_time = pd.to_datetime("14:30").time()
 end_time = pd.to_datetime("21:00").time()
 else:
 start_time = pd.to_datetime("15:30").time()
 end_time = pd.to_datetime("22:00").time()
 
 filtered_data = day_data[(day_data['time'].dt.time >= start_time) & (day_data['time'].dt.time <= end_time)]
 
 if not filtered_data.empty:
 high_max = filtered_data['high'].max()
 low_min = filtered_data['low'].min()
 amplitude = high_max - low_min
 df.loc[df['date'] == day, 'amp_journée'] = amplitude
percentages = [25, 50, 75, 100, 125, 150, 175, 200, 225, 250, 275]
for p in percentages:
 df[f'{p}%'] = df['amp_journée'] * (p / 100)
 df[f'-{p}%'] = df['amp_journée'] * (-p / 100)
cols = ['date', 'time', 'open', 'high', 'low', 'close', 'Modedate', 'amp_journée']
percentage_cols = [f'{p}%' for p in percentages] + [f'-{p}%' for p in percentages]
df = df[cols + percentage_cols]
# Interface graphique principale
root = tk.Tk()
root.title("Graphique en chandelier japonais")
root.state('zoomed')
frame = ttk.Frame(root)
frame.pack(fill=tk.BOTH, expand=True)
start_index = 0
num_candles = 100
# Champs pour les pas
step_frame = ttk.Frame(root)
step_frame.pack(side=tk.TOP, fill=tk.X)
tk.Label(step_frame, text="Pas graphique:").pack(side=tk.LEFT, padx=5)
graph_step_entry = ttk.Entry(step_frame, width=5)
graph_step_entry.insert(0, "30")
graph_step_entry.pack(side=tk.LEFT, padx=5)
tk.Label(step_frame, text="Pas zoom:").pack(side=tk.LEFT, padx=5)
zoom_step_entry = ttk.Entry(step_frame, width=5)
zoom_step_entry.insert(0, "30")
zoom_step_entry.pack(side=tk.LEFT, padx=5)
# Fenêtre pour afficher le DataFrame
def show_dataframe():
 df_window = tk.Toplevel(root)
 df_window.title("Tableau des données")
 df_window.state('zoomed')
 tree_frame = ttk.Frame(df_window)
 tree_frame.pack(fill=tk.BOTH, expand=True)
 tree_scroll_y = ttk.Scrollbar(tree_frame, orient=tk.VERTICAL)
 tree_scroll_x = ttk.Scrollbar(tree_frame, orient=tk.HORIZONTAL)
 tree = ttk.Treeview(tree_frame, yscrollcommand=tree_scroll_y.set, xscrollcommand=tree_scroll_x.set)
 tree_scroll_y.pack(side=tk.RIGHT, fill=tk.Y)
 tree_scroll_x.pack(side=tk.BOTTOM, fill=tk.X)
 tree_scroll_y.config(command=tree.yview)
 tree_scroll_x.config(command=tree.xview)
 tree.pack(fill=tk.BOTH, expand=True)
 df_display = df.copy().reset_index()
 numeric_columns = ['amp_journée'] + [col for col in df_display.columns if '%' in col] + ['open', 'high', 'low', 'close']
 for column in numeric_columns:
 if column in df_display.columns:
 df_display[column] = df_display[column].round(2)
 tree["columns"] = ["index"] + list(df_display.columns)[1:]
 tree["show"] = "headings"
 tree.heading("index", text="Index")
 tree.column("index", width=50, anchor='center')
 for column in df_display.columns[1:]:
 tree.heading(column, text=column)
 if column == 'time':
 tree.column(column, width=200, anchor='center')
 else:
 tree.column(column, width=100, anchor='center')
 for _, row in df_display.iterrows():
 tree.insert("", "end", values=[row['index']] + list(row)[1:])
 # Champ de saisie pour l'index
 index_frame = ttk.Frame(df_window)
 index_frame.pack(side=tk.TOP, fill=tk.X)
 tk.Label(index_frame, text="Index:").pack(side=tk.LEFT, padx=5)
 index_entry = ttk.Entry(index_frame, width=10)
 index_entry.pack(side=tk.LEFT, padx=5)
 def select_by_index(event=None):
 index = index_entry.get()
 if index.isdigit():
 index = int(index)
 for item in tree.get_children():
 if int(tree.item(item)['values'][0]) == index:
 tree.selection_set(item)
 tree.see(item)
 break
 index_entry.bind('<Return>', select_by_index)
 df_window.mainloop()
btn_show_df = ttk.Button(root, text="Afficher le tableau", command=show_dataframe)
btn_show_df.pack(side=tk.TOP, pady=5)
# Ajouter une ligne rouge et verte
def add_lines(ax, df_slice):
 try:
 unique_dates = df_slice['date'].unique()
 for date in unique_dates:
 daily_data = df_slice[df_slice['date'] == date]
 if daily_data.empty:
 continue
 
 modedate = daily_data['Modedate'].iloc[0]
 if modedate == 1:
 start_time = pd.to_datetime("14:30").time()
 end_time = pd.to_datetime("21:00").time()
 else:
 start_time = pd.to_datetime("15:30").time()
 end_time = pd.to_datetime("21:55").time()
 
 filtered_data = daily_data[
 (daily_data['time'].dt.time >= start_time) & 
 (daily_data['time'].dt.time <= end_time)
 ]
 
 if filtered_data.empty:
 continue
 
 max_high = filtered_data['high'].max()
 min_low = filtered_data['low'].min()
 
 time_range = df_slice['time']
 xmin = (pd.Timestamp.combine(date, start_time) - time_range.min()).total_seconds() / (time_range.max() - time_range.min()).total_seconds()
 xmax = (pd.Timestamp.combine(date, end_time) - time_range.min()).total_seconds() / (time_range.max() - time_range.min()).total_seconds()
 
 ax.axhline(y=max_high, color='red', linestyle='--', xmin=xmin, xmax=xmax)
 ax.axhline(y=min_low, color='green', linestyle='--', xmin=xmin, xmax=xmax)
 except Exception as e:
 pass
# fonction pour gérer le mouvement de la souris
def on_mouse_move(event):
 if event.inaxes:
 x, y = event.xdata, event.ydata
 ax = event.inaxes
 
 # Effacer les lignes précédentes
 for line in ax.lines:
 if line.get_label() in ['crosshair_h', 'crosshair_v']:
 line.remove()
 
 # Dessiner les nouvelles lignes
 ax.axhline(y=y, color='black', linewidth=0.5, label='crosshair_h')
 ax.axvline(x=x, color='black', linewidth=0.5, label='crosshair_v')
 
 # Mettre à jour les données dans la fenêtre
 if df_slice is not None and len(df_slice) > 0:
 index = max(0, min(int(x), len(df_slice) - 1))
 data = df_slice.iloc[index]
 info_text = f"Index: {start_index + index}\nOpen: {data['open']:.2f}\nHigh: {data['high']:.2f}\nLow: {data['low']:.2f}\nClose: {data['close']:.2f}\nTime: {data['time']}"
 info_window.set(info_text)
 
 # Mise à jour des valeurs X et Y
 x_value.set(f"X: {data['time']}")
 y_value.set(f"Y: {y:.2f}")
 
 # Redessiner le graphique
 fig.canvas.draw_idle()
# Evènement molette de la sourie
def on_scroll(event):
 global num_candles
 if event.button == 'up':
 num_candles = max(num_candles - int(zoom_step_entry.get()), 10)
 elif event.button == 'down':
 num_candles += int(zoom_step_entry.get())
 update_chart()
# Fonctions pour le graphique
def update_chart():
 global start_index, num_candles, df_slice, fig
 plt.close('all') # Ferme toutes les figures existantes
 df_slice = df.iloc[start_index:start_index + num_candles]
 if df_slice.empty:
 return
 df_ohlc = df_slice[['time', 'open', 'high', 'low', 'close']].copy()
 df_ohlc.set_index('time', inplace=True)
 fig, axlist = mpf.plot(df_ohlc, type='candle', style='charles', title=csv_filename,
 ylabel='Prix', volume=False, returnfig=True)
 ax = axlist[0]
 add_lines(ax, df_slice)
 if hasattr(frame, "canvas"):
 frame.canvas.get_tk_widget().destroy()
 canvas = FigureCanvasTkAgg(fig, master=frame)
 canvas.draw()
 canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)
 frame.canvas = canvas
 fig.canvas.mpl_connect('motion_notify_event', on_mouse_move)
 fig.canvas.mpl_connect('scroll_event', on_scroll)
def increase_candles():
 global num_candles
 num_candles += int(zoom_step_entry.get())
 update_chart()
def decrease_candles():
 global num_candles
 num_candles = max(num_candles - int(zoom_step_entry.get()), 10) # Minimum de 10 chandeliers
 update_chart()
def move_right():
 global start_index
 start_index += int(graph_step_entry.get())
 update_chart()
def move_left():
 global start_index
 start_index = max(start_index - int(graph_step_entry.get()), 0)
 update_chart()
# Boutons
button_frame = ttk.Frame(root)
button_frame.pack(side=tk.BOTTOM, fill=tk.X)
plus_button = ttk.Button(button_frame, text="+", command=decrease_candles)
plus_button.pack(side=tk.LEFT, padx=5, pady=5)
minus_button = ttk.Button(button_frame, text="-", command=increase_candles)
minus_button.pack(side=tk.LEFT, padx=5, pady=5)
left_button = ttk.Button(button_frame, text="←", command=move_left)
left_button.pack(side=tk.LEFT, padx=5, pady=5)
right_button = ttk.Button(button_frame, text="→", command=move_right)
right_button.pack(side=tk.LEFT, padx=5, pady=5)
# Fenêtre d'information
info_frame = ttk.Frame(root)
info_frame.pack(side=tk.BOTTOM, fill=tk.X)
# Sous-frame pour les informations centrées
center_info_frame = ttk.Frame(info_frame)
center_info_frame.pack(side=tk.LEFT, expand=True)
info_window = tk.StringVar()
info_label = ttk.Label(center_info_frame, textvariable=info_window, justify=tk.LEFT)
info_label.pack(pady=10)
# Sous-frame pour les valeurs X et Y à droite
xy_info_frame = ttk.Frame(info_frame)
xy_info_frame.pack(side=tk.RIGHT)
x_value = tk.StringVar()
y_value = tk.StringVar()
x_label = ttk.Label(xy_info_frame, textvariable=x_value, justify=tk.LEFT)
y_label = ttk.Label(xy_info_frame, textvariable=y_value, justify=tk.LEFT)
x_label.pack(padx=10, anchor='w')
y_label.pack(padx=10, anchor='w')
update_chart()
root.mainloop()