TurtleTrade/TurtleOnTime copy.py

import numpy as np
import math
import akshare as ak
import os
from datetime import datetime, timedelta, date
import pandas as pd
import mplfinance as mpf
import mysql_database
from EmailTest import send_email, parse_return_email
from dataclasses import dataclass
import time
import threading
import yaml  # 添加YAML支持

'''
todo

1 运行过程框架调整，支持多个turtle同时监测
2 增加运行状态写入yaml文件，读取文件恢复状态
'''

@dataclass
class BuyState:
    trigger_time: float # 触发次数
    buy_price: float # 买入价格
    add_price: float # 加仓价格
    stop_price: float # 止损价格
    is_gap_up: bool # 是否跳空高开
    shares: int # 买入股数
    atr: int # ATR
    available_cash: float # 可用资金
    
@dataclass
class TradeLog:
    data: str # 时间
    type: str # 操作类型
    buy_price: float # 买入价格
    shares: int # 买入股数
    cost: float # 成本
    atr: int # ATR
    available_cash: float # 可用资金
    all_shares: float # 总股数
    all_cost: float # 总成本
    Net_value: float # 净值
    Net_return: float # 净收益

@dataclass 
class BreakOutLog:
    # 记录突破信息
    data: str # 时间
    breakout_price: float # 突破价格
    lose_price: float # 亏损价格
    valid_or_not: str # 是否有效
    win_or_lose: bool # 是否盈利

def calc_sma_atr_pd(kdf,period):
    """计算TR与ATR

    Args:
        kdf (_type_): 历史数据
        period (_type_): ATR周期

    Returns:
        _type_: 返回kdf，增加TR与ATR列
    """
    kdf['最高'] = kdf['最高'].astype(float)
    kdf['最低'] = kdf['最低'].astype(float)
    kdf['收盘'] = kdf['收盘'].astype(float)
    kdf['HL'] = kdf['最高'] - kdf['最低']
    kdf['HC'] = np.abs(kdf['最高'] - kdf['收盘'].shift(1))
    kdf['LC'] = np.abs(kdf['最低'] - kdf['收盘'].shift(1))
    kdf['TR'] = np.round(kdf[['HL','HC','LC']].max(axis=1), 3)
    # ranges = pd.concat([high_low, high_close, low_close], axis=1)
    # true_range = np.max(ranges, axis=1)
    kdf['ATR'] = np.round(kdf['TR'].rolling(period).mean(), 3)
    
    return kdf.drop(['HL','HC','LC'], axis = 1)

class TurtleTrading(object):
    """对象范围较小，对某一个标的创建一个海龟，如513300，
    计算ATR、唐奇安通道线
    基础数据
    Args:
        object (_type_): _description_
    """
    def __init__(self, TradeCode, type, riskcoe, Capital, cash) -> None:
        self.TradeCode = TradeCode
        self.type = type
        self.riskcoe = riskcoe
        self.Capital = Capital
        self.cash = cash
        self.TrigerTime = 0
        self.BuyStates = list[BuyState]
        
        self.tradeslog = list[TradeLog]
        self.BreakOutLog = list[BreakOutLog]
        self.PriceNow = 0.0
        self.Donchian_20_up = 0.0
        self.Donchian_10_down = 0.0
        self.Donchian_50_up = 0.0
        self.is_gap_up = False # 是否跳空高开
        self.prev_heigh = 0.0 # 前一天最高价

    
    def GetRecentData(self):
        """获取某个标的的最近数据，从两年前到今天, 计算后的数据保存在self.CurrentData

        Returns:
            _type_: _description_
        """
        Today = datetime.today()
        # print(Today)
        formatted_date = Today.strftime("%Y%m%d")
        two_years_ago = (date.today() - timedelta(days=365*2)).strftime("%Y%m%d")
        # print(formatted_date)
        Code = f"{self.TradeCode}"
        CurrentData = ak.fund_etf_hist_em(symbol=Code, period="daily", start_date=two_years_ago, end_date=formatted_date, adjust="")
        
        # 将日期列转换为datetime
        CurrentData = pd.DataFrame(CurrentData)
        CurrentData['日期'] = pd.to_datetime(CurrentData['日期'])
        # print(type(CurrentData['日期'].iloc[0]))
        
        CurrentData.set_index('日期', inplace=True)
        # CurrentData.reset_index(inplace=True)
        # print(type(CurrentData['日期'].iloc[0]))
        # create table
        # stock_database.create_table(Code)
        # stock_database.insert_data(Code, CurrentData)
        # mysql_database.insert_db(CurrentData, Code, True, "'日期'")
        self.CurrentData = CurrentData
        # return self.CurrentData

        
    def CalATR(self, data, ATRday):
        """计算某个标的的ATR，从上市日到今天, 计算后的数据保存在self.CurrentData

        Args:
            ATRday: 多少日ATR
            SaveOrNot (_type_): 是否保存.csv数据
        """

        self.CurrentData = calc_sma_atr_pd(data, ATRday)
        self.N = self.CurrentData['ATR']

        
        # return self.N
    

    def ReadExistData(self, data):
        """除了通过发请求获取数据，也可以读本地的数据库，赋值给self.CurrentData

        Args:
            data (_type_): 本地csv名称
        """
        self.CurrentData = pd.read_csv(data)

    def DrawKLine(self, days):
        """画出k线图看看,画出最近days天的K线图
        """
        
        # 日期部分

        # dates = pd.to_datetime(self.CurrentData['日期'][-days:])
        # # Klinedf['Data'] = pd.to_datetime(self.CurrentData['日期'])
        Klinedf = pd.DataFrame()
        # Klinedf.set_index = Klinedf['Data']
        
        # 其他数据
        Klinedf['Date'] = self.CurrentData['日期'][-days:]
        Klinedf['Open'] = self.CurrentData['开盘'][-days:].astype(float)
        Klinedf['High'] = self.CurrentData['最高'][-days:].astype(float)
        Klinedf['Low'] = self.CurrentData['最低'][-days:].astype(float)
        Klinedf['Close'] = self.CurrentData['收盘'][-days:].astype(float)
        Klinedf['Volume'] = self.CurrentData['成交量'][-days:].astype(float)
        
        Klinedf.set_index(pd.to_datetime(Klinedf['Date']), inplace=True)
        # 画图
        mpf.plot(Klinedf, type='candle', style='yahoo', volume=False, mav=(5,), addplot=[mpf.make_addplot(self.Donchian_up['Upper'][-days:]), mpf.make_addplot(self.Donchian_down['lower'][-days:])], title=f"{self.TradeCode} K线图")
    
    def calculate_donchian_channel_up(self, n):
        """
        计算n日唐奇安上通道

        参数:
        self.CurrentData (DataFrame): 包含价格数据的Pandas DataFrame，包含"High"
        n (int): 时间周期

        返回:self.Donchian
        DataFrame: 唐奇安通道的DataFrame，包含"Upper"
        """
        Donchian = pd.DataFrame()  # 创建一个空的DataFrame用于存储唐奇安通道数据
        # 计算最高价和最低价的N日移动平均线
        name = 'Donchian_' + str(n) + '_upper'
        Donchian[name] = self.CurrentData['最高'].rolling(n).max()  # 使用rolling函数计算n日最高价的移动最大值

        # # 计算中间线
        # Donchian['Middle'] = (self.Donchian['Upper'] + self.Donchian['Lower']) / 2  # 计算上通道和下通道的中间线，但此行代码被注释掉了

        return Donchian  # 返回包含唐奇安上通道的DataFrame
    
    def calculate_donchian_channel_down(self, n):
        """
        计算n日唐奇安上通道

        参数:
        self.CurrentData (DataFrame): 包含价格数据的Pandas DataFrame，包含"High"
        n (int): 时间周期

        返回:self.Donchian
        DataFrame: 唐奇安通道的DataFrame，包含"Upper"
        """
        Donchian = pd.DataFrame()
        # 计算最高价和最低价的N日移动平均线
        name = 'Donchian_' + str(n) + '_lower'
        Donchian[name] = self.CurrentData['最低'].rolling(n).min()

        # # 计算中间线
        # Donchian['Middle'] = (self.Donchian['Upper'] + self.Donchian['Lower']) / 2

        return Donchian
    
    def calc_atr_donchian_short(self):
        """计算ATR、短期唐奇安通道
        """
                    # 计算ATR
        self.CalATR(self.CurrentData, 20)
        # 计算唐奇安通道
        self.Donchian_20_ups = self.calculate_donchian_channel_up(20)
        self.Donchian_50_ups = self.calculate_donchian_channel_up(50)
        self.Donchian_downs = self.calculate_donchian_channel_down(10)
        # 画图
        # self.DrawKLine(days)
        
        # 把self.N, self.Donchian_up, self.Donchian_down, 添加到self.CurrentData后面，保存到mysql数据库
        self.CurrentData = pd.concat([self.CurrentData, self.Donchian_20_ups, self.Donchian_50_ups, self.Donchian_downs], axis=1)

    def get_ready(self, days):
        """创建一个turtle对象，获取数据，计算ATR，计算唐奇安通道

        Args:
            days (_type_): _description_
            n (_type_): _description_
        """
        
        # if 不存在database
        if not mysql_database.check_db_table(f"{self.TradeCode}"):
            self.GetRecentData()
            
            self.calc_atr_donchian_short()
            Code = f"{self.TradeCode}"
            mysql_database.insert_db(self.CurrentData, Code, True, "日期")
        else:

        # 检查数据库最后一条的时间距离今天是否两天以上
            current_date = date.today()
            threshold_date = current_date - timedelta(days=2)
            last_update = mysql_database.check_db_table_last_date(f"{self.TradeCode}")
        
            if  last_update < threshold_date:
                # 如果不存在，则从akshare获取数据并保存到mysql数据库
                mysql_database.delete_table(f"{self.TradeCode}")
                    
                self.GetRecentData()
                
                self.calc_atr_donchian_short()

                Code = f"{self.TradeCode}"
                mysql_database.insert_db(self.CurrentData, Code, True, "日期")
            else:
                # 如果存在，则从mysql数据库中读取数据
                self.CurrentData = mysql_database.fetch_all_data(f"{self.TradeCode}")
            
        
    def CalPositionSize(self):
        """根据风险系数、ATR，计算仓位大小, 存于self.IntPositionSize
        """
        PositionSize = self.riskcoe * self.Capital /(self.N)  # 默认用股票形式了 100
        self.IntPositionSize = int(PositionSize // 100) * 100

    def system1EnterNormal(self, PriceNow, TempDonchian20Upper, BreakOutLog):
        # 没有持仓且价格向上突破---此时包含两种情形：1 对某标的首次使用系统，2 已发生过突破，此时上次突破天然是失败的
        if self.TrigerTime == 0 and PriceNow > TempDonchian20Upper:
        # 买入
            return True
        elif  PriceNow > TempDonchian20Upper:#todo !=0不会满足条件 先跳过 
            self.system1BreakoutValid(PriceNow)
            if BreakOutLog[-1].win_or_lose == None: # TT!= 0且突破且上一次突破unseccessful
                return True
            else:
                return False
        else:
            return False
        
        
    def system1EnterSafe(self, PriceNow, TempDonchian55Upper):
        
        if PriceNow > TempDonchian55Upper[-1]: # 保底的55日突破
            return True
        else:
            return False
        
    def system1BreakoutValid(self, priceNow):
        """判断前一次突破是否成功，是log[-1][5]写入“win”，否则写入“Lose”
        """
        if priceNow < self.BreakOutLog[-1].lose_price:
            self.BreakOutLog[-1].win_or_lose = None
        else:
            self.BreakOutLog[-1].win_or_lose = True
    # 一天结束，计算ATR，计算唐奇安通道，追加到已有的mysql数据库中
    
    def system_1_Out(self, PriceNow, TempDonchian10Lower):
        # 退出:低于20日最低价（多头方向）,空头以突破20日最高价为止损价格--有持仓且价格向下突破
        if self.TrigerTime != 0 and PriceNow < TempDonchian10Lower:
            # 退出
            return True
        
        else:
            return False
    def add(self, PriceNow):
        """加仓
        """
        if self.TrigerTime < 4 and PriceNow > self.BuyStates[self.TrigerTime - 1].add_price:#todo BuyStates是空的
            # 买入
            return True
        else:
            return False
        
    def system_1_stop(self, PriceNow):
        """止损判断：如果当前价格<上一次买入后的止损价格则止损
        """
        if PriceNow < self.BuyStates[self.TrigerTime - 1].stop_price:
            # 买入
            return True
        else:
            return False 
        
    def day_end(self):
        """Save current state to YAML file at the end of the day"""
        # Create state directory if not exists
        state_dir = "state"
        if not os.path.exists(state_dir):
            os.makedirs(state_dir)
        
        # Generate filename with current date
        today = datetime.now().strftime("%Y-%m-%d")
        filename = os.path.join(state_dir, f"{today}.yaml")
        
        # Save state to YAML
        state_data = {
            "turtles": [
                {
                    "TradeCode": t.TradeCode,
                    "type": t.type,
                    "riskcoe": t.riskcoe,
                    "Capital": t.Capital,
                    "cash": t.cash,
                    "TrigerTime": t.TrigerTime,
                    "BuyStates": [vars(bs) for bs in t.BuyStates],
                    "tradeslog": [vars(tl) for tl in t.tradeslog],
                    "BreakOutLog": [vars(bol) for bol in t.BreakOutLog],
                    "PriceNow": t.PriceNow,
                    "Donchian_20_up": t.Donchian_20_up,
                    "Donchian_10_down": t.Donchian_10_down,
                    "Donchian_50_up": t.Donchian_50_up,
                    "is_gap_up": t.is_gap_up,
                    "prev_heigh": t.prev_heigh
                } for t in self.turtles
            ]
        }
        
        with open(filename, 'w') as f:
            yaml.dump(state_data, f)
        
class TurtleTrading_OnTime(object):
    ''' 实时监测主程序，可以处理多个turtle
     
    1、获取实时大盘数据
    2、根据turtles的代码，比较是否触发条件
    3、实时监测主流程
    '''
    
    def load_previous_state(self):
        """Load previous state from YAML file if exists"""
        state_dir = "state"
        today = datetime.now().strftime("%Y-%m-%d")
        yesterday = (datetime.now() - timedelta(days=1)).strftime("%Y-%m-%d")
        filename = os.path.join(state_dir, f"{yesterday}.yaml")
        
        if os.path.exists(filename):
            with open(filename, 'r') as f:
                state_data = yaml.safe_load(f)
                
            # Restore state
            for turtle_data in state_data.get('turtles', []):
                # Find or create TurtleTrading instance
                turtle = next((t for t in self.turtles if t.TradeCode == turtle_data['TradeCode']), None)
                if not turtle:
                    # Create new instance if not found (should not happen)
                    turtle = TurtleTrading(**turtle_data)
                    self.turtles.append(turtle)
                
                # Restore attributes
                turtle.TradeCode = turtle_data['TradeCode']
                turtle.type = turtle_data['type']
                turtle.riskcoe = turtle_data['riskcoe']
                turtle.Capital = turtle_data['Capital']
                turtle.cash = turtle_data['cash']
                turtle.TrigerTime = turtle_data['TrigerTime']
                turtle.BuyStates = [BuyState(**bs) for bs in turtle_data['BuyStates']]
                turtle.tradeslog = [TradeLog(**tl) for tl in turtle_data['tradeslog']]
                turtle.BreakOutLog = [BreakOutLog(**bol) for bol in turtle_data['BreakOutLog']]
                turtle.PriceNow = turtle_data['PriceNow']
                turtle.Donchian_20_up = turtle_data['Donchian_20_up']
                turtle.Donchian_10_down = turtle_data['Donchian_10_down']
                turtle.Donchian_50_up = turtle_data['Donchian_50_up']
                turtle.is_gap_up = turtle_data['is_gap_up']
                turtle.prev_heigh = turtle_data['prev_heigh']

    def __init__(self, turtles: list[TurtleTrading], user_email):
        self.turtles = turtles  # List of TurtleTrading instances
        self.user_email = user_email
        self.email_events = {}  # Track email response events for each turtle
        
        # Load previous state from YAML if exists
        self.load_previous_state()
        
    def get_stocks_data(self):
        """获取实时股票、基金数据，不保存
        """
        stock_data = ak.stock_zh_a_spot_em()
        stock_data = stock_data.dropna(subset=['最新价'])
        # # print(stock_zh_a_spot_df)
        # # stock_zh_a_spot_df第一列加上时间，精确到分钟
        # stock_zh_a_spot_df['时间'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        # mysql_database.insert_db(stock_zh_a_spot_df, "stock_price", True, "代码")
        
        etf_data = ak.fund_etf_spot_em()
        # etf_data = ak.fund_etf_spot_ths()
        # etf_data = etf_data.dropna(subset=['当前-单位净值'])
        etf_data = etf_data.dropna(subset=['最新价'])
        
        # etf_data['时间'] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        # mysql_database.insert_db(etf_data, "etf_price", True, "代码")
        return stock_data, etf_data

    def Buy_stock(self, turtle: TurtleTrading, price_now):
        # 发送邮件 代码self.turtle.TradeCode, 建议买入价格price_now，买入份额self.turtle.IntPositionSize
        
            
        
        subject = "买入"
        body = f"{turtle.TradeCode}，价格{price_now}，份额{turtle.IntPositionSize} \n "
        body += "回复：实际买入价格-买入份额-手续费"
        send_email(subject, body, self.user_email)
        send_email_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        
        #每隔1分钟检测回信，解析邮件。
        
        parsed_email_flag = False
        while not parsed_email_flag:
            time.sleep(60)  # 每次尝试前等待 60 秒
            parse_states, buy_price, buy_share, fee = parse_return_email(
                self.user_email, send_email_time
            )
            
            if parse_states:
                parsed_email_flag = True
                break
            
        # 成功买入
        turtle.TrigerTime += 1
        # 记录self.turtle.BuyStates
        add_price = buy_price + 1/2 * turtle.N
        stop_price = buy_price - 2 * turtle.N
        cost = buy_price * buy_share - fee
        available_cash = turtle.Capital - cost
        
        buy_this_time = BuyState(turtle.TrigerTime, 
                                buy_price, 
                                add_price, 
                                stop_price,
                                False,
                                buy_share, 
                                turtle.N, 
                                available_cash)

        turtle.BuyStates.append(buy_this_time)
        
        # 记录self.turtle.tradeslog
        today = datetime.now().strftime("%Y-%m-%d")
        log_this_time = TradeLog(today,
                                "买入",
                                buy_price,
                                buy_share,
                                cost,
                                turtle.N,
                                available_cash,
                                all_shares=buy_share, 
                                all_cost=cost,
                                Net_value=buy_price * buy_share,
                                Net_return=0)
        turtle.tradeslog.append(log_this_time)
            
            
            
            
    
    def add_stock(self, turtle: TurtleTrading, price_now):
        """加仓

        Args:
            price_now (_type_): 现价
        """
        
        # 加仓
        
        subject = "加仓"
        body = f"{turtle.TradeCode}，价格{price_now}，份额{turtle.IntPositionSize} \n "
        body += "回复：实际买入价格-买入份额-手续费"
        send_email(subject, body, self.user_email)
        send_email_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        #每隔1分钟检测回信，解析邮件。

        parsed_email_flag = False
        while not parsed_email_flag:
            time.sleep(60)  # 每次尝试前等待 60 秒
            parse_states, buy_price, buy_share, fee = parse_return_email(
                self.user_email, send_email_time
            )
            
            if parse_states:
                parsed_email_flag = True
                break
        
        # 成功买入
        turtle.TrigerTime += 1
        # 记录self.turtle.BuyStates
        add_price = buy_price + 1/2 * turtle.N
        stop_price = buy_price - 2 * turtle.N
        cost = buy_price * buy_share - fee
        available_cash = turtle.BuyStates[-1].available_cash - cost
        all_shares = buy_share + turtle.BuyStates[-1].all_shares
        all_cost = cost + turtle.BuyStates[-1].all_cost
        net_value = buy_price * all_shares
        net_return = net_value - all_cost
        buy_this_time = BuyState(turtle.TrigerTime, 
                                buy_price, 
                                add_price, 
                                stop_price,
                                turtle.is_gap_up, 
                                buy_share,
                                turtle.N, 
                                available_cash)

        turtle.BuyStates.append(buy_this_time)


        today = datetime.now().strftime("%Y-%m-%d")
        log_this_time = TradeLog(today,
                                "加仓",
                                buy_price,
                                buy_share,
                                cost,
                                turtle.N,
                                available_cash,
                                all_shares,
                                all_cost,
                                net_value,
                                net_return)
        turtle.tradeslog.append(log_this_time)
        
        # 处理其他次买入的止损价格
        # 检查BuyStates中有几个gap_up,返回个数和索引
        gap_up_num = 0
        gap_up_index = []
        for i in range(len(turtle.BuyStates)):
            if turtle.BuyStates[i].is_gap_up:
                gap_up_num += 1
                gap_up_index.append(i)
        if gap_up_num == 0:
            # 之前BuyStates中的stop_price = stop_price
            for j in range(len(turtle.BuyStates)):
                turtle.BuyStates[j].stop_price = stop_price
        
        if not turtle.is_gap_up and  gap_up_num == 1:
            if gap_up_index[0] == 1:
                number_tobe_change = turtle.TrigerTime -1 - gap_up_index[0]
                for k in range(number_tobe_change):
                    turtle.BuyStates[k+1].stop_price = stop_price  
                    
            elif gap_up_index[0] == 2:
                turtle.BuyStates[2].stop_price = stop_price
                
        elif not turtle.is_gap_up and gap_up_num == 2:
            number_tobe_change = 2
            for k in range(number_tobe_change):
                turtle.BuyStates[k+1].stop_price = stop_price

        
    def stop_sale_stock(self, turtle: TurtleTrading, price_now):
        """止损卖出

        Args:
            price_now (_type_): 现价
        """
        
        # 判断需要卖出几份
        sale_shares = 0
        for i in range(len(turtle.BuyStates)):
            if price_now <= turtle.BuyStates[i].stop_price:
                sale_shares += 1
                break
        # 比较price_now与self.turtle.BuyStates[-1].stop_price
        
        # 发送邮件 代码self.turtle.TradeCode, 建议卖出价格price_now，卖出份额self.turtle.IntPositionSize
        subject = "止损卖出"
        body = f"{turtle.TradeCode}，价格{price_now}，份额{turtle.IntPositionSize * sale_shares} \n "
        body += "回复：实际卖出价格-卖出份额-手续费"
        send_email(subject, body, self.user_email)
        send_email_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        
        # 每隔1分钟检测回信，解析邮件。

        parsed_email_flag = False
        while not parsed_email_flag:
            time.sleep(60)  # 每次尝试前等待 60 秒
            parse_states, sale_price, sale_share, fee = parse_return_email(
                self.user_email, send_email_time
            )
            
            if parse_states:
                parsed_email_flag = True
                break        

        
        # 成功卖出
        turtle.TrigerTime -= sale_shares
        # 记录self.turtle.BuyStates
        available_cash = turtle.BuyStates[-1].available_cash + sale_price * sale_share - fee
        
        # 删除BuyStates中卖出股票的记录
        turtle.BuyStates = turtle.BuyStates[:-sale_shares]
        
        
        sale_this_time = TradeLog(datetime.now().strftime("%Y-%m-%d"),
                                    "止损",
                                    sale_price,
                                    sale_share,
                                    sale_price * sale_share - fee,
                                    turtle.N,
                                    available_cash,
                                    all_shares=0,
                                    all_cost=0,
                                    Net_value=sale_price * sale_share,
                                    Net_return=abs(turtle.Capital - available_cash))
        turtle.tradeslog.append(sale_this_time)
        
    def out_sale_stock(self, turtle: TurtleTrading, price_now):
        """止盈卖出

        Args:
            price_now (_type_): 现价
        """
        
        # 发送邮件 代码self.turtle.TradeCode, 建议卖出价格price_now，卖出份额self.turtle.IntPositionSize
        subject = "止盈卖出"
        body = f"{turtle.TradeCode}，价格{price_now}，份额{turtle.IntPositionSize} \n "
        body += "回复：实际卖出价格-卖出份额-手续费"
        send_email(subject, body, self.user_email)
        send_email_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        
        # 每隔1分钟检测回信，解析邮件。

        parsed_email_flag = False
        while not parsed_email_flag:
            time.sleep(60)  # 每次尝试前等待 60 秒
            parse_states, sale_price, sale_share, fee = parse_return_email(
                self.user_email, send_email_time
            )
            
            if parse_states:
                parsed_email_flag = True
                break        

        # 成功卖出
        turtle.TrigerTime = 0
        # 记录self.turtle.BuyStates
        available_cash = turtle.BuyStates[-1].available_cash + sale_price * sale_share - fee
        turtle.BuyStates = []
        
        sale_this_time = TradeLog(datetime.now().strftime("%Y-%m-%d"),
                                    "止盈",
                                    sale_price,
                                    sale_share,
                                    sale_price * sale_share - fee,
                                    turtle.N,
                                    available_cash,
                                    all_shares=0,
                                    all_cost=0,
                                    Net_value=sale_price * sale_share,
                                    Net_return=abs(turtle.Capital - available_cash))
        turtle.tradeslog.append(sale_this_time)

    # def run_short_trading_loop(self, stock_data, etf_data):

    #     now = datetime.now().time()
    #     # 根据类型获取当前价格
    #     if self.turtle.type == "stock":
    #         self.turtle.PriceNow = float(stock_data.loc[etf_data['代码'] == self.turtle.TradeCode, '最新价'].values[0])

    #     elif self.turtle.type == "etf":
    #         # self.turtle.PriceNow = float(etf_data.loc[etf_data['基金代码'] == self.turtle.TradeCode, '当前-单位净值'].values[0])
    #         self.turtle.PriceNow = float(etf_data.loc[etf_data['代码'] == self.turtle.TradeCode, '最新价'].values[0])

    #     # # 9点30 判断是否跳空高开
    #     if now.hour == 9 and now.minute == 30 and self.turtle.PriceNow > self.turtle.prev_heigh:
    #         self.turtle.is_gap_up = True
            
            
    #     # 判断当前仓位状态并执行相应操作
    #     if self.turtle.TrigerTime == 0:
    #         # 空仓状态
    #         if self.turtle.system1EnterNormal(
    #             self.turtle.PriceNow,
    #             self.turtle.Donchian_20_up,
    #             self.turtle.BreakOutLog
    #         ):
    #             self.Buy_stock(self.turtle.PriceNow)
                
    #             # 突破 记录self.turtle.breakoutlog
    #             today = datetime.now().strftime("%Y-%m-%d")
    #             breakout_this_time = BreakOutLog(today,
    #                                             self.turtle.Donchian_20_up, 
    #                                             self.turtle.Donchian_20_up - 2 * self.turtle.N,
    #                                             'valid',
    #                                             None)
    #             self.turtle.BreakOutLog.append(breakout_this_time)

    #         elif self.turtle.system1EnterSafe(
    #             self.turtle.PriceNow,
    #             self.turtle.Donchian_50_up
    #         ):
    #             self.Buy_stock(self.turtle.PriceNow)

    #     elif 1 <= self.turtle.TrigerTime <= 3:
    #         # # 突破状态
    #         # if self.turtle.system1EnterNormal(
    #         #     self.turtle.PriceNow,
    #         #     self.turtle.Donchian_20_up,
    #         #     self.turtle.BreakOutLog
    #         # ):
    #         #     self.Buy_stock(self.turtle.PriceNow)
    #         # elif self.turtle.system1EnterSafe(
    #         #     self.turtle.PriceNow,
    #         #     self.turtle.Donchian_50_up
    #         # ):
    #         #     self.Buy_stock(self.turtle.PriceNow)
            
    #         # 加仓状态
    #         if self.turtle.add(self.turtle.PriceNow):
    #             self.add_stock(self.turtle.PriceNow)
                
    #         # 止损状态
    #         elif self.turtle.system_1_stop(self.turtle.PriceNow):
    #             self.stop_sale_stock(self.turtle.PriceNow)
            
    #         # 止盈
    #         elif self.turtle.system_1_Out(
    #             self.turtle.PriceNow,
    #             self.turtle.Donchian_10_down
    #         ):
    #             self.out_sale_stock(self.turtle.PriceNow)

    #     elif self.turtle.TrigerTime == 4:
    #         # 满仓  止损 止盈
    #         if self.turtle.system_1_stop(self.turtle.PriceNow):
    #             self.stop_sale_stock(self.turtle.PriceNow)
    #         elif self.turtle.system_1_Out(
    #             self.turtle.PriceNow,
    #             self.turtle.Donchian_10_down
    #         ):
    #             self.out_sale_stock(self.turtle.PriceNow)

    #     # 等待 1 分钟后下一次循环
    #     time.sleep(60)
        
    def Start_short_system(self):
        """启动short系统
        """
        
        # ------------------准备阶段--------------------
        # 获取数据或读取数据  -- 计算ATR Donchian 20 50 up, 20 down
        # 初始化所有turtle
        for turtle in self.turtles:
            # 准备数据
            turtle.get_ready(100)
            turtle.N = float(turtle.CurrentData['ATR'].iloc[-1])
            turtle.prev_heigh = float(turtle.CurrentData['最高价'].iloc[-1])
            turtle.Donchian_20_up = float(turtle.CurrentData['Donchian_20_upper'].iloc[-1])
            turtle.Donchian_50_up = float(turtle.CurrentData['Donchian_50_upper'].iloc[-1])
            turtle.Donchian_10_down = float(turtle.CurrentData['Donchian_10_lower'].iloc[-1])
            turtle.CalPositionSize()
        # ------------------实时监测阶段--------------------
        # 9:00 1、判断是否是新的一周，是则重新计算Position Size
        # 判断是否是新的一周
        if datetime.now().weekday() == 0:
            for turtle in self.turtles:
                turtle.CalPositionSize()
            
        # 每分钟获取一次数据，判断是否触发条件 9:30-11:30 13:00-15:00
        while True:
            # 获取当前时间
            now = datetime.now().time()

            # 判断当前时间是否在交易时段内（9:30-11:30 或 13:00-15:00）
            is_trading_time = (
                (now.hour == 9 and now.minute >= 30) or
                (now.hour == 10 and 0 <= now.minute <= 59) or
                (now.hour == 11 and now.minute <= 30) or
                (now.hour == 13 and 0 <= now.minute <= 59) or
                (now.hour == 14 and 0 <= now.minute <= 59) or
                (now.hour == 15 and now.minute <= 0)
            )


                
            if not is_trading_time:
                # 非交易时间，等待 1 分钟后继续循环
                time.sleep(60)
                continue
            
            is_stop_time = (now.hour > 15 and now.minute > 0) #收盘时间
            if is_stop_time:
                break

            # 获取股票和ETF数据
            self.monitor_all_turtles()
            # 等待一段时间后再次检查
            time.sleep(60)  # 每分钟检查一次
        # ------------------结束阶段--------------------
        # 数据库更新当天数据，增加ATR、donchian数据
        # 直接做个新表
        for turtle in self.turtles:
            mysql_database.delete_table(f"{turtle.TradeCode}")
            turtle.get_ready(100)
            time.sleep(16.5*600)


    def monitor_all_turtles(self):
        """主监控循环"""
        # 获取实时数据
        stock_data, etf_data = self.get_stocks_data()
        
        # 遍历所有turtle进行监控
        for turtle in self.turtles:
            self.monitor_single_turtle(turtle, stock_data, etf_data)
        

    
    def monitor_single_turtle(self, turtle: TurtleTrading, stock_data, etf_data):
        """监控单个turtle的交易条件"""

        now = datetime.now().time()
        if turtle.type == "stock":
            turtle.PriceNow = float(stock_data.loc[etf_data['代码'] == self.turtle.TradeCode, '最新价'].values[0])

        elif turtle.type == "etf":
            # self.turtle.PriceNow = float(etf_data.loc[etf_data['基金代码'] == self.turtle.TradeCode, '当前-单位净值'].values[0])
            turtle.PriceNow = float(etf_data.loc[etf_data['代码'] == self.turtle.TradeCode, '最新价'].values[0])
        
        if now.hour == 9 and now.minute == 30 and self.turtle.PriceNow > self.turtle.prev_heigh:
            turtle.is_gap_up = True
            
        # 判断当前仓位状态并执行相应操作
        if turtle.TrigerTime == 0:
            if turtle.system1EnterNormal(
                turtle.PriceNow,
                turtle.Donchian_20_up,
                turtle.BreakOutLog
            ):
                
                self.start_email_thread(turtle, "买入", turtle.PriceNow)
                
                # 突破 记录self.turtle.breakoutlog
                today = datetime.now().strftime("%Y-%m-%d")
                breakout_this_time = BreakOutLog(today,
                                                turtle.Donchian_20_up, 
                                                turtle.Donchian_20_up - 2 * turtle.N,
                                                'valid',
                                                None)
                turtle.BreakOutLog.append(breakout_this_time)

            elif turtle.system1EnterSafe(
                turtle.PriceNow,
                turtle.Donchian_50_up
            ):
                self.start_email_thread(turtle, "买入", turtle.PriceNow)
                
        elif 1 <= turtle.TrigerTime <= 3:
            
            # 加仓状态
            if turtle.add(turtle.PriceNow):
                self.start_email_thread(turtle, "加仓", turtle.PriceNow)
                
            # 止损状态
            elif turtle.system_1_stop(turtle.PriceNow):
                self.start_email_thread(turtle, "止损", turtle.PriceNow)
            
            # 止盈
            elif turtle.system_1_Out(
                turtle.PriceNow,
                turtle.Donchian_10_down
            ):
                self.start_email_thread(turtle, "止盈", turtle.PriceNow)
            
        elif turtle.TrigerTime == 4:
            # 满仓  止损 止盈
            if turtle.system_1_stop(turtle.PriceNow):
                self.start_email_thread(turtle, "止损", turtle.PriceNow)
            elif turtle.system_1_Out(
                turtle.PriceNow,
                turtle.Donchian_10_down
            ):
                self.start_email_thread(turtle, "止盈", turtle.PriceNow)

    def start_email_thread(self, turtle:TurtleTrading, action, price_now):
        """启动邮件处理线程"""
        event = threading.Event()
        self.email_events[turtle.TradeCode] = event
        
        thread = threading.Thread(
            target=self.handle_email_response,
            args=(turtle, action, price_now, event)
        )
        thread.start()
    
    def handle_email_response(self, turtle:TurtleTrading, action, price_now, event):
        """处理邮件响应的线程"""
        # 发送邮件
        if action == "买入":
            self.Buy_stock(turtle, price_now)
        elif action == "加仓":
            self.add_stock(turtle, price_now)
        elif action == "止损":
            self.stop_sale_stock(turtle, price_now)
        elif action == "止盈":
            self.out_sale_stock(turtle, price_now)
        
        # 等待邮件响应
        event.wait()

if __name__ == '__main__':
    
    user_email = "guoyize2209@163.com"
    t = TurtleTrading('513870', "etf", 0.0025, 100000, 200000)
    # t.get_ready(100)
    
    a = TurtleTrading_OnTime(t, user_email)
    a.Start_short_system()

    # # 全是股票
    # stock_zh_a_spot_df = ak.stock_zh_a_spot_em()
    # # stock_zh_a_spot_df.to_csv("stock_zh_a_spot.txt", sep="\t", index=False, encoding="utf-8")
    # stock_zh_a_spot_df = stock_zh_a_spot_df.dropna(subset=['最新价'])
    # print(stock_zh_a_spot_df)
    
    # # 全是基金
    # etf_data = ak.fund_etf_spot_em()
    # etf_data = etf_data.dropna(subset=['最新价'])
    # etf_data.to_csv("fund_etf_spot.txt", sep="\t", index=False, encoding="utf-8")
    # print(etf_data)