# 載入 API 套件
from taishin_sdk import TaishinSDK, Order, BSAction, TimeInForce, OrderType, PriceType, MarketType

# 載入相關套件
import math
import json

# 載入 line-notify 套件
import lineTool

symbolId = "6285"  # 取得股票代碼
SP = 0.2  # 訂定停利％數
SL = 0.1  # 訂定停損％數

# 因考量讀者可能尚未開戶 or 目前無庫存可在這裡測試，可自行更改成本價
price_avg = 70
qty = 2000 # 2 張

class StopProfitStrategy:

    def __init__(self, symbol_id, sp_ratio, sl_ratio):
        # 初始化交易 API 並取得 sdk object
        self.sdk = self._init_fugle_trade()

        self.LINE_NOTIFY_TOKEN = "INPUT_YOUR_LINE_TOKEN" # INPUT_YOUR_LINE_TOKEN

        # 設定交易標的（取庫存股票）
        self.symbol = symbol_id

        # 設定停利比例
        self.sp_ratio = sp_ratio

        # 設定停損比例
        self.sl_ratio = sl_ratio

        # # 初始化庫存價格及成交量
        # self.price_avg = price_avg
        # self.qty = qty

        # 最新價格
        self.now_price = None

    # 交易 API 設定檔的部分
    def _init_fugle_trade(self):

        # 登入
        sdk = TaishinSDK()
        accounts = sdk.login("Your ID", "Your Password", "Your Cert Path", "Your Cert Password")

        return sdk, accounts

    def sell(self, qty, price_type, OrderType):

        order = Order(
            buy_sell=BSAction.Sell,
            price_type=PriceType,
            price = '',
            symbol=self.symbol,
            quantity=qty,
            time_in_force=TimeInForce.ROD,
            order_type=OrderTyep,
            market_type=MarketType.Common   # 現股賣出 的交易類別
        )

        self.sdk.place_order(order)

    def sell_total_shares(self, qty):

        if qty >= 1000:
            # 計算預計賣出張數 -> 小數點無條件捨去
            vol = math.floor(qty/1000)
            # 市價、整股賣
            # self.sell(vol, 'Market', 'Common')
            # 測試用、漲停賣(避免真的賣掉)
            self.sell(vol, 'LimitUp', 'Common')


            # 若還有零股需再下零股單
            # 賣出剩下的零股
            odd_vol = qty - vol*1000
            if odd_vol > 0:
                # 跌停價、盤中零股賣
                # self.sell(odd_vol, 'LimitDown', 'IntradayOdd') # 零股預約單帶 Odd ，盤中零股帶 IntradayOdd
                # 測試用、漲停賣(避免馬上賣掉)
                self.sell(odd_vol, 'LimitUp', 'IntradayOdd') # 零股預約單帶 Odd ，盤中零股帶 IntradayOdd

        # 庫存不足一張時
        elif qty < 1000:
            # 跌停價、盤中零股賣
            # self.sell(qty, 'LimitDown', 'IntradayOdd') # 零股預約單帶 Odd ，盤中零股帶 IntradayOdd
            # 測試用、漲停賣(避免馬上賣掉)
            self.sell(qty, 'LimitUp', 'IntradayOdd') # 零股預約單帶 Odd ，盤中零股帶 IntradayOdd

    # 取得庫存 - 成交均價、成交股數
    def get_inventoryInfo(self):

        try:
            print('get_inventoryInfo start')
            # 檢查庫存資料
            inventories_list = self.sdk.get_inventories()

            # 取得指定的庫存股票
            spec_symbol = list(filter(lambda x:x['stk_no']==self.symbol, inventories_list))
            price_avg = float(spec_symbol[0]['price_avg'])

            # 取得該股票庫存股數
            qty = int(spec_symbol[0]["cost_qty"])

            print('get_inventoryInfo done')
            return price_avg, qty
        
        except Exception as e:
            print('get_inventoryInfo error: {}', e)

    # 取得最新報價
    def get_latest_price(self, message):

        json_data = json.loads(message)

        print(json_data)

        if json_data['event']=="data" and json_data.get('data',{}).get('isTrial') == None: # 避免用到試撮資料
            # 更新目前價格
            self.now_price = json_data['data']['price']

            print('最新價格：', self.now_price)

            self.run_strategy(self.price_avg, self.qty)


        elif json_data['event']=="snapshot": # 盤後測試
            # 更新目前價格
            self.now_price = json_data['data']['price']
 
            print('收盤價格：', self.now_price)

                   
            self.run_strategy(self.price_avg, self.qty)

    def handle_disconnect(self, code, message):
        print(f'disconnect: {code}, {message}')

    def main(self, price_avg, qty):
        
        # 取庫存中，該股票的成本價及庫存股數
        # self.price_avg, self.qty = self.get_inventoryInfo()

        # # 若您目前尚未有庫存可自行設置一個成本價（500元）及庫存股數（1000股）
        # self.price_avg, self.qty = 500, 1000

        self.sdk.init_realtime(self.accounts[0])
        self.stock = sdk.marketdata.websocket_client.stock
        self.stock.on('message', self.get_latest_price)
        self.stock.on("disconnect", self.handle_disconnect)

        self.stock.connect()

        self.stock.subscribe({
            'channel': 'trades',
            'symbol': self.symbol
        })


    def run_strategy(self, price_avg, qty):

        try:
            print('get_run_strategy start!')

            if self.now_price is not None:

                # 達到 停利條件 就進行平倉操作：
                if self.now_price >= price_avg*(1+self.sp_ratio) :

                    # 平倉
                    # self.sell_total_shares(qty)

                    msg = '\n'+ f'達到停利條件：{self.sp_ratio*100} %'+'\n'+\
                          '賣出' + str(self.symbol) +'\n'+ str(self.now_price) +'元' + '\n' + str(qty) + "股"

                    print(msg)
                    #line notify 通知
                    lineTool.lineNotify(self.LINE_NOTIFY_TOKEN, msg)
                    self.stock.disconnect() # 達條件後，中斷連線

                    
                # 達到 停損條件 就進行平倉操作：
                elif  self.now_price <= price_avg*(1-self.sl_ratio):
                    
                    # 平倉
                    # self.sell_total_shares(qty)

                    # 預計回傳 line notify 通知的訊息
                    msg = '\n'+ f'達到停損條件：{self.sl_ratio*100} %'+'\n'+\
                          '賣出' + str(self.symbol) +'\n'+ str(self.now_price) +'元' + '\n' + str(qty) + "股"

                    print(msg)
                    # 執行 line notify 通知
                    lineTool.lineNotify(self.LINE_NOTIFY_TOKEN, msg)
                    self.stock.disconnect() # 達條件後，中斷連線
                else:
                    print("尚未達到停損停利條件！")
                    print("----")

        except Exception as e:
            print('get_run_strategy error: {}', e)


if __name__ == '__main__':
    strategy = StopProfitStrategy(symbolId, SP, SL)
    strategy.main(price_avg, qty)

from taishin_sdk import TaishinSDK, Order, BSAction, TimeInForce, OrderType, PriceType, MarketType
 
# 登入
sdk = TaishinSDK()
accounts = sdk.login("Your ID", "Your Password", "Your Cert Path", "Your Cert Password")

# 取得行情權限
sdk.init_realtime(accounts[0])

# 使用行情 API
restStock = sdk.marketdata.rest_client.stock 

# 確認您是否有當沖權限 
user_dayTrade_status = accounts[0].s_mark

symbol = "2603"
# 須先確認該股票是否可以先買後賣
symbol_canDayBuySell = restStock.intraday.ticker(symbol=symbol)['canBuyDayTrade']

# 使用相關套件
import datetime
import time

# 用來記錄部位狀態
position = 0

# 確認是否有當沖權限：Y -> 已開啟先買後賣的當沖權限、B -> 已開啟先買後賣、先賣後買的當沖權限
if user_dayTrade_status not in ['Y','B']: 
    raise Exception("您目前無法進行先買後賣的當沖操作！") 

# 須確認該檔股票是否可以當沖
if symbol_canDayBuySell == False:
    raise Exception("您選擇的股票無法進行先買後賣操作，請換檔股票試試！")

# 首先我們必須要隨時檢查目前的時間是否是這兩個時間點
while True:
    # 時間是9點
    if datetime.time(9, 1) >= datetime.datetime.now().time() > datetime.time(9, 0) and position == 0:
        order = Order(
            buy_sell= BSAction.Buy,
            price_type=PriceType.Market,  # 市價買進
            price='',
            symbol=symbol,
            quantity=1000,
            market_type=MarketType.Common,
            order_type=OrderType.Stock,
        )
        sdk.stock.place_order(accounts[0],order)
        # 已經買進，避免重複下單
        position = position + 1  # position 為 0 指沒有部位、position 為 1 指有部位
    
    # 已經到收盤時間 且 有部位
    if datetime.time(13, 26) >= datetime.datetime.now().time() >= datetime.time(13, 25) and position != 0:
        order = OrderObject(
            buy_sell= BSAction.Sell,
            price_type=PriceType.LimitDown,  # 跌停賣出
            price='',
            symbol=symbol,
            quantity=1000,
            market_type=MarketType.Common,
            order_type=OrderType.DayTradingSell,  # 為現股當沖賣出，因此以交易類別來說需要設定為現股當沖賣（DayTradingSell）
        )
        sdk.stock.place_order(order)
        # 已經賣出，部位歸零
        position = 0
        break

# 取得最新報價
def _on_new_price(message):
    json_data = json.loads(message)

    # 查看整股行情
    if json_data['event']=="data" and json_data.get('data',{}).get('isTrial') == None: # 避免用到試撮資料
        # 更新目前價格
        now_price = json_data['data']['price']
        print(now_price)

def create_ws_quote(symbol):

    stock = sdk.marketdata.websocket_client.stock
    stock.on("message", _on_new_price)
    stock.connect()
    stock.subscribe({
        'channel': 'trades',
        'symbol': symbol
    })


if __name__ == '__main__':
    create_ws_quote("2330")  

import json
import time
import datetime

# 載入交易 API 相關套件
from taishin_sdk import TaishinSDK, Order, BSAction, TimeInForce, OrderType, PriceType, MarketType

class ORB_Strategy:

    # 預計賣出時間
    SELL_TIME = datetime.time(13, 25)
    
    def __init__(self, symbol, orb_percent):
        self.sdk , self.accounts = self._init_fugle_trade()
        self.orb_percent = orb_percent / 100
        self.symbol = str(symbol)
        self.open_price = None
        self.position = 0


    # 交易 API 設定檔的部分
    def _init_fugle_trade(self):

        # 登入
        sdk = TaishinSDK()
        accounts = sdk.login("Your ID", "Your Password", "Your Cert Path", "Your Cert Password")

        return sdk, accounts


    def __place_order(self, action, price_type, order_type):
        order = OrderObject(
            buy_sell=BSAction,
            price_type=price_type,
            price='',
            symbol=self.symbol,
            quantity=1000,
            market_type=MarketType.Common,
            order_type=order_type
        )
        self.sdk.place_order(order)

    def check_trade_status(self):
        
        user_day_trade_status = self.accounts[0].s_mark
        
        # 須先確認您是否有當沖權限
        if user_day_trade_status not in ['Y','B']:
            raise Exception("您目前無法進行先買後賣的當沖操作！")
            
        self.restStock = self.sdk.marketdata.rest_client.stock 
        # 須先確認該股票是否可以先買後賣
        symbol_can_day_trade = self.restStock.intraday.ticker(symbol=self.symbol).get('canBuyDayTrade', False)

        # 須先確認該股票是否可以先買後賣當沖，若為 True 代表可以先買後賣當沖，會開始執行策略
        if symbol_can_day_trade == False:
            raise Exception("您選擇的股票無法進行先買後賣操作，請換檔股票試試！")  

    def get_open_price(self):
        self.open_price = self.restStock.intraday.quote(symbol = self.symbol)['openPrice']

    def run_buy_strategy(self, message):
        json_data = json.loads(message)

        if json_data['event'] == "data" and json_data.get('data',{}).get('isTrial') == None:
            # 取最新成交價
            now_price = json_data['data']['price']

            # 策略判斷
            if self.position == 0 and now_price >= self.open_price * (1 + self.orb_percent):
                self.__place_order(BSAction.Buy, PriceType.Market, OrderType.Common) # 以市價買進
                self.position += 1
                print(f"達開盤價 + {self.orb_percent*100}%  條件：已掛漲停買進 {self.symbol} 一張！")
    
    def handle_error(self, error):
        print(f'error: {error}')
        
    def calculate_wait_seconds(self, target_time):
        now = datetime.datetime.now()
        target_datetime = datetime.datetime.combine(now.date(), target_time) 
        delta = target_datetime - now # 計算當下與預定賣出時間的時間差
        return max(0, delta.total_seconds())

    def run_sell_strategy(self):
        time.sleep(self.calculate_wait_seconds(self.SELL_TIME))  
        if self.position > 0:
            self.__place_order(BSAction.Sell, PriceType.LimitDown, OrderType.DayTradingSell)
            self.position = 0
            print(f"即將收盤，已掛跌停賣出 {self.symbol} 一張！")

    def main(self):
        self.sdk.init_realtime(self.accounts[0])
        stock = sdk.marketdata.websocket_client.stock
        stock.on('message', self.run_buy_strategy)
        stock.connect()
        stock.on("error", self.handle_error)
        stock.subscribe({
            'channel': 'trades',
            'symbol': self.symbol
        })
        self.run_sell_strategy()

if __name__ == '__main__':
    orb_strategy = ORB_Strategy('2603', 3)
    orb_strategy.check_trade_status()
    orb_strategy.get_open_price()
    orb_strategy.main()

# 載入相關套件
from taishin_sdk import TaishinSDK
import numpy as np

# 設定相關參數
symbol = "2603"
start_date = "2022-08-01" # 選擇資料起始日期
end_date = "2022-08-31"  # 選擇資料結束日期

# 透過自己的行情 API key 取得歷史資料
sdk = TaishinSDK()
accounts = sdk.login("Your ID", "Your Password", "Your Cert Path", "Your Cert Password")

# 取得行情權限
sdk.init_realtime(accounts[0])

# 使用行情 API
stock = sdk.marketdata.rest_client.stock 

# 取得歷史資料
history_options = {"symbol": symbol, "from": start_date, "to": end_date, "timeframe":"D"}
historical_data = stock.historical.candles(**history_options)

# 損益金額  = 計算開盤買收盤賣的價差 * 1張
profit_loss = list(map(lambda x:round((x['close']-x['open'])*1000), historical_data['data']))

# 以手續費 2.8 折、交易稅減半來計算
trade_fee = 0.001425*0.28
trade_tax = 0.003/2

# 交易成本
trade_cost = list(map(lambda x:round((x['close']+x['open'])*1000*trade_fee+(x['close'])*1000*trade_tax),historical_data['data']))

# 所得淨利 = 損益金額 - 交易成本
profit_loss_record = (np.array(profit_loss)-np.array(trade_cost)).tolist()

# 投入本金
buy_cost = list(map(lambda x:round((x['open'])*1000), historical_data['data']))

# 記錄每筆報酬率（已考量交易成本）
return_record = (np.array(profit_loss_record) / np.array(buy_cost)).tolist()
# 將報酬率簡化為小數點第四位內
return_record = list(map(lambda x:round(x*100,2),return_record))
print(return_record)

# 每筆交易的報酬率
[1.03, -0.34, -0.34, -1.08, -0.12, -3.38, 0.3, -1.58, -0.94, -0.33, 0.08, -2.15, -3.15, 0.25, -2.13, -1.19, 3.72, 2.62, 2.88, 0.63, -1.5, -2.02, 0.5]

# 勝率
# 先篩選損益大於 0 的次數
profit_list = list(filter(lambda x : x > 0, profit_loss_record))
# 勝率 = 損益大於 0 的次數 / 交易總數
win_rate = len(profit_list) / len(profit_loss_record)
print("勝率：",win_rate)

# 賺賠比
# 篩選損益小於 0 的結果
loss_list = list(filter(lambda x : x <= 0, profit_loss_record))
# 賺賠比 = 平均賺 / 平均賠
odds = (sum(profit_list) /len(profit_list)) / abs(sum(loss_list)/len(loss_list))
print("賺賠比：",odds)

# 獲利因子
# 獲利因子 = 賺總和 / 賠總和
profit_factor = sum(profit_list) / abs(sum(loss_list))
print("獲利因子",profit_factor)

# 長榮（2603.tw）回測結果
勝率：39.13 %
賺賠比：0.91
獲利因子：0.59

# M31 (6643.tw）回測結果
# 每筆交易的報酬率
[8.25, 0.68, 3.94, -4.28, 3.27, -1.74, -1.14, -2.89, -3.8, 3.2, 2.79, -2.87, 5.46, 10.38, 6.79, 1.26, 4.41, 0.16, 0.57, -1.23, -2.98, -1.22, -2.15]

勝率：56.52 %
賺賠比：1.56
獲利因子：2.03

# 安裝相關套件
!pip install finlab
!pip install talib-binary # 若您尚未安裝 TA-Lib 計算技術指標的套件，建議您先安裝

# 載入相關套件
from finlab import data
from finlab.backtest import sim

close=data.get('price:收盤價')
ma5 = data.indicator('SMA', resample='D', timeperiod=5)
ma10 = data.indicator('SMA', resample='D', timeperiod=10)
ma60 = data.indicator('SMA', resample='D', timeperiod=60)

entries = ma5 > ma10  # 進場條件
exits = ma60 > ma5    # 出場條件

symbol = ['2603']     # 可換成其他個股或多檔個股

position = entries.hold_until(exits)[symbol]
report = sim(position, upload=True, mae_mfe_window = 40, name = '均線策略範例') # 查看視覺化回測結果
trade_record = report.trades # 可查看透過此策略的逐筆交易紀錄

close=data.get('price:收盤價')
upperband, middleband, lowerband = data.indicator('BBANDS', resample='D', nbdevup=2.0, nbdevdn=2.0, timeperiod=20)

entries = close > upperband  # 收盤價大於上軌線
exits = lowerband > close    # 收盤價小於下軌線

symbol = ['2603']

position = entries.hold_until(exits)[symbol]
report = sim(position, upload=True, mae_mfe_window=40, name='布林通道範例')
trade_record = report.trades # 可查看透過此策略的逐筆交易紀錄

close = data.get('price:收盤價')
MACD, MACDsignal, MACDhist = data.indicator('MACD', resample='D', fastperiod=12, slowperiod=26,signalperiod=9)

entries = MACD > MACDsignal
exits = MACDsignal > MACD

symbol = ['2603']

position = entries.hold_until(exits)[symbol]
report = sim(position,upload=True,mae_mfe_window=40, name='MACD')
trade_record = report.trades