from tick_trade_api import TradeAPI

#初始化TradeAPI时需要指定下单策略，MarketPolicy为市价下单；LimitPolicy为限价下单
trade_api=TradeAPI('89898238',order_policy=MarketPolicy)

source_code= r"""
import collections
import pandas as pd
from datetime import datetime, timedelta
import numpy as np
from collections import OrderedDict
from tick_trade_api import TradeAPI
# 初始化函数,全局只运行一次
def init(context):
     # 设置基准收益：沪深300指数
     set_benchmark('000300.SH')
     # 打印日志
     log.info('策略开始运行,初始化函数全局只运行一次')
     # 设置股票每笔交易的手续费为万分之二(手续费在买卖成交后扣除,不包括税费,税费在卖出成交后扣除)
     set_commission(PerTrade(type='stock',cost=0.1))
     # 设置股票交易滑点0%
     set_slippage(PriceSlippage(0))
     # 设置日级最大成交比例25%,分钟级最大成交比例50%
     # 日频运行时，下单数量超过当天真实成交量25%,则全部不成交
     # 分钟频运行时，下单数量超过当前分钟真实成交量50%,则全部不成交
     set_volume_limit(0.25,0.5)
     # 设置要操作的股票：同花顺
     run_daily(func=test_day, time_rule='every_bar', reference_security='000001.SZ')
     # 设置记忆容器
     g.gpjy = pd.DataFrame({})
     # 初始化记录值
     g.yxcs = 0
     
     # 设置价格昨日价格上限
     g.sp_max = 135
     # 设置价格昨日价格下限
     g.sp_min = 115
     # 设置过去3日成交额均值上限
     g.cj_max = 1e9
     # 设置过去3日成交额均值下限
     g.cj_min = 1e8
     # 设置现价大于金叉的幅度
     g.xjzf_max = 0.98 
     # 设置金叉5周期均线大于上一周期均线的幅度
     g.jxzf_max = 1.0003
     # 设置周期是多少分钟
     g.zq = '30m'
     # 设置长周期均线为多少周期
     g.zqts_max = 5
     # 设置短周期均线为多少周期
     g.zqts_min = 3
     # 设置止盈
     g.zy = 1.025
     # 设置止损
     g.zs = 0.985
     # 设置持仓周期上限
     g.zqsx = 10
     # 设置持仓上限
     g.ccsx = 2
     # 设置模式
     g.jyms = "模拟"
     
#盘前选股
def before_trading(context):
     # 获取特殊时间格式
     g.date = get_datetime().strftime('%Y-%m-%d')
     # 获取前30个交易日
     g.sr = get_trade_days(None, g.date, 30)
     # 获取当日所有债券
     g.kzzs = list(pd.DataFrame(get_all_securities('cbond', g.sr[-1])).T.columns)
     g.kzzs.remove('123234.SZ')
     # 获取成交额前3日均值
     pjz = get_price(g.kzzs, None, g.sr[-2], '1d', ['turnover'], True, None, 3, is_panel=1)['turnover'].mean()
     # 筛选成交额小于1亿,并大于1千万的债券
     pjz = list(pd.DataFrame(pjz[(pjz < g.cj_max) & (pjz > g.cj_min)]).T.columns)
     # 获取昨日价格
     zsps = get_price(pjz, None, g.sr[-2], '1d', ['close'], True, None, 1, is_panel=1)['close']
     # 筛选价格大于100并小于130的
     g.zsps = list(zsps.loc[:, ((zsps > g.sp_min) & (zsps < g.sp_max)).any()])
# 以000001为基准，开盘后每分钟运行一次
def test_day(context, bar_dict):
     # 获取时间
     time = get_datetime()
     # 获取周期实际值
     zqz = int(g.zq.split('m')[0])
     # 获取当前时间上一根30分钟线结束时间
     hqfz = int(float(str(time).split(' ')[1].split(':')[1])/zqz)*zqz
     # 获取上个周期结束时间
     gdsj = get_datetime().replace(minute=hqfz)
     # 获取持仓
     chicangs = list(context.portfolio.positions)
     # 组合债券池
     zd_gps=list(collections.OrderedDict.fromkeys(chicangs+g.zsps))
     # 初始化运行次数
     yxsx = 1
     # 记录天数
     if gdsj == time:
         # 每运行一次，周期减1
         g.gpjy = g.gpjy.sub(1)
     # 判断是否有持仓,无持仓则30分钟运行一次
     if len(context.portfolio.positions) == 0:
         yxsj = gdsj
     else:
         yxsj = time
     # 优化运行速度
     if time == yxsj:    
         for zd_gp in zd_gps:
             timewl = get_datetime()+timedelta(minutes=1)
             # 获取下单金额
             xdje = context.portfolio.stock_account.total_value/g.ccsx
             # 获取可用资金
             kyzj = context.portfolio.stock_account.available_cash
             # 取得当前账户该债券的持仓
             market_value = context.portfolio.positions[zd_gp].amount
             # 取得当前账户该债券的可卖股数
             kmgs = context.portfolio.positions[zd_gp].available_amount
             # 取得当前债券成本价
             cbj = context.portfolio.positions[zd_gp].cost_basis
             # 取得当前债券持仓数量
             zqzs = len(context.portfolio.positions)
             if g.jyms == "模拟":
                # 获取当前最新价
                value = get_price(zd_gp, None, timewl, '1m', ['open'], True, None, 1, is_panel=1)['open'].mean() 
             elif g.jims == "回测":
                # 获取当前最新价
                value = get_price(zd_gp, None, time, '1m', ['close'], True, None, 1, is_panel=1)['close'].mean()
             # 获取长周期均线
             jxmax = get_price(zd_gp, None, gdsj, g.zq, ['close'], True, None, g.zqts_max, is_panel=1)['close'].mean()
             # 获取上周期的长周期均线
             jxmaxz = get_price(zd_gp, None, gdsj, g.zq, ['close'], True, None, g.zqts_max+1, is_panel=1)['close'].iloc[:5].mean()
             # 获取长周期均线与上周期均线差值
             jxcz = jxmax/jxmaxz
             # 获取短周期均线
             jxmin = get_price(zd_gp, None, gdsj, g.zq, ['close'], True, None, g.zqts_min, is_panel=1)['close'].mean()
             # 获取上周期的短周期均线
             jxminz = get_price(zd_gp, None, gdsj, g.zq, ['close'], True, None, g.zqts_min+1, is_panel=1)['close'].iloc[:3].mean()
             # 获取现价与金叉差值
             jccz = value/jxmax
             # 计算每组数量
             shuliang = int(xdje/value/10)*10
             # 记录天数
             if zd_gp in g.gpjy.index:
                 # 获取运行次数
                 g.yxcs = g.gpjy.loc[zd_gp, 'value']
             elif zd_gp not in g.gpjy.index:
                 # 初始化运行次数
                 g.yxcs = 0
             # 计算当前债券的盈利情况     
             yl = 0
             # 判断是否有持仓
             if cbj != 0:
                 # 获取盈利
                 yl = value/cbj
             # 判断是否符合买入条件
             if market_value == 0 and kyzj > xdje and jxminz < jxmaxz and jxmin > jxmax and jccz > g.xjzf_max and jxcz > g.jxzf_max and gdsj == time and zqzs <= g.ccsx and g.yxcs <= 0:
                 # 记录这次买入
                 log.info("出现金叉，" + str(value) + "买入 %s" % (zd_gp))
                 # 按照每组数量下单
                 order(zd_gp, shuliang)
                 # 取得当前账户该债券的持仓
                 hqdd = context.portfolio.positions[zd_gp].amount
                 # 下单成功则记录
                 if hqdd > 0:
                     # 记录该股票
                     g.gpjy = g.gpjy.append(pd.DataFrame(dict(value=[g.zqsx]), index=[zd_gp]))
             # 判断持仓是否满足16个周期    
             elif market_value > 0 and g.yxcs <= 0 and gdsj == time:
                 # 记录这次交易
                 log.info("持仓满" + str(g.zqsx) + "个周期，" + str(value) + "卖出 %s" % (zd_gp))
                 # 按照每组数量下单
                 order_target(zd_gp, 0)
                 # 取得当前账户该债券的持仓
                 hqdd = context.portfolio.positions[zd_gp].amount
                 # 下单成功则删除
                 if hqdd == 0:
                     # 记录该债券记录
                     g.gpjy = g.gpjy.drop(zd_gp)                
             # 判断是否符合止盈条件
             elif market_value > 0 and yl >= g.zy:
                 # 记录这次交易
                 log.info("止盈，" + str(value) + "卖出 %s" % (zd_gp))
                 # 按照每组数量下单
                 order_target(zd_gp, 0)
                 # 取得当前账户该债券的持仓
                 hqdd = context.portfolio.positions[zd_gp].amount
                 # 下单成功则删除
                 if hqdd == 0:
                     # 记录该债券记录
                     g.gpjy = g.gpjy.drop(zd_gp) 
             # 判断是否符合止损条件
             elif market_value > 0 and yl <= g.zs:
                 # 记录这次交易
                 log.info("止损，" + str(value) + "卖出 %s" % (zd_gp))
                 # 卖出所有股票,使这只股票的最终持有量为0
                 order_target(zd_gp, 0)
                 # 取得当前账户该债券的持仓
                 hqdd = context.portfolio.positions[zd_gp].amount 
                 # 下单成功则删除
                 if hqdd == 0:
                     # 记录该债券记录
                     g.gpjy = g.gpjy.drop(zd_gp)
                 
             yxsx += 1    
             if (yxsx > g.ccsx*2 and zqzs >= g.ccsx) or (yxsx > g.ccsx*2 and gdsj != time):
                 break

# 收盘后运行函数,用于储存自定义参数、全局变量,执行盘后选股等
def after_trading(context):
     log.info('一天结束')
"""
rtrade = research_trade(
    '新建策略2',
     source_code,
     frequency='MINUTE', 
     trade_api=trade_api,
     signal_mode=False,
     recover_dt='today'
)