class RedisCls:



    def __init__(self):

        self.conn = self.getConn()



    def getConn(self):

        try:

            r = redis.Redis(host=redisconfig['redis']['host'], port=redisconfig['redis']['port'], db=0,

                            decode_responses=True, password=redisconfig['redis']['password'], socket_connect_timeout=5)

        except Exception as e:

            print(e)

            raise IOError('connect redis failed')

        else:

            return r

        



    def get(self, key):

        return self.conn.get(key)

    



    def set(self, key, value):

        return self.conn.set(key, value)

    

    def pop(self, key):

        print('==== pop data ====')

        return self.conn.brpop(key)



    def push(self, key, value):

        print('==== push data ====')

        self.conn.blpush(key, value)

AttributeError: 'Redis' object has no attribute 'blpush'. Did you mean: 'lpush'?

def initialize(context):

    run_daily(context, event, '09:38')





def handle_data(context, data):

    pass





def event(context):

    his60 = get_history(60, '1d', ['close'],  ['515220.SS'], fq='pre', include=False)

    print(his60)

# coding:gbk

def init(C):

    pass



def handlebar(C):

    iopv = get_etf_iopv("159928.SZ")

    print(f'基金净值为{iopv}')

    info = get_etf_info('513520.SH')

    print(f'基金申购信息： {info}')

# coding:gbk

# 公众号:可转债量化分析

DEBUG = True

import time

def get_datetime(ContextInfo):

    # 获取当前时间

    index = ContextInfo.barpos

    realtime = ContextInfo.get_bar_timetag(index)

    date = timetag_to_datetime(realtime, "%Y-%m-%d %H:%M:%S")

    if DEBUG:

        print('当前日期 ', date)

    return date

    

def init(ContextInfo):

    print("==============start==========")

    ContextInfo.start = '2024-03-27 10:00:00'

    ContextInfo.end = '2024-03-29 10:00:00'

    # 

    #ContextInfo.end = '2023-01-05'

    #ContextInfo.start = '2023-01-16'

    print('init')

    

def handlebar(ContextInfo):

    # 回测的时候不需要

    #if not ContextInfo.is_last_bar():

    #    print('return')

    #    return

    get_datetime(ContextInfo)

    print('handlebar')

    data = ContextInfo.get_market_data(['quoter'], stock_code = ['123167.SZ'], skip_paused = True, period = 'tick', dividend_type = 'front')

    

    #data = ContextInfo.get_market_data(['close'], stock_code = ['113567.SH'], skip_paused = True, period = '1d', dividend_type = 'front')

    #print(type(data))

    print(data)



def stop(ContextInfo):

    print( 'strategy is stop !')

import akshare as ak

fund_purchase_em_df = ak.fund_purchase_em()

def filter_func(df,type='指数型-海外股票'):

    df = df[~df['基金代码'].str.startswith('0')]

    condition1 = df['申购状态']=='限大额'

    condition2 = df['基金类型']==type

    df = df[condition1 & condition2]

    df= df[~df['基金简称'].str.contains('ETF')]

    df = df[(df['日累计限定金额']>0) & (df['日累计限定金额']<=10000)]

    df['基金代码'] = df['基金代码'].map(lambda x: 'SH'+x if x.startswith('5') else 'SZ'+x)

    return df

import requests

cookies = # 雪球上获取，不一定需要登录状态



headers = {

    'authority': 'stock.xueqiu.com',

    'origin': 'https://xueqiu.com',

    'user-agent': 'Mozilla/5.0 (iPhone; U; CPU like Mac OS X; en) AppleWebKit/420+ (KHTML, like Gecko) Version/3.0 Mobile/1C28 Safari/419.3',

}



def fund_premium_rate(code):

    params = {

        'symbol': code,

        'extend': 'detail',

    }



    response = requests.get('https://stock.xueqiu.com/v5/stock/quote.json', params=params, 

                            cookies=cookies, 

                            headers=headers)

    try:

        rate = response.json()['data']['quote']['premium_rate']

    except Exception as e:

        return None

    else:

        return rate

for code,name in code_name_mapper.items():

    rate = fund_premium_rate(code)

    if rate is not None:

        print(f'{code} - {name}的溢价率是: {rate}')

        if rate > 4:

            send_message_via_wechat(f'{code} - {name}的溢价率是: {rate}, 可以关注套利。 公众号：可转债量化分析')

# 用前须知



## xtdata提供和MiniQmt的交互接口，本质是和MiniQmt建立连接，由MiniQmt处理行情数据请求，再把结果回传返回到python层。使用的行情服务器以及能获取到的行情数据和MiniQmt是一致的，要检查数据或者切换连接时直接操作MiniQmt即可。



## 对于数据获取接口，使用时需要先确保MiniQmt已有所需要的数据，如果不足可以通过补充数据接口补充，再调用数据获取接口获取。



## 对于订阅接口，直接设置数据回调，数据到来时会由回调返回。订阅接收到的数据一般会保存下来，同种数据不需要再单独补充。



# 代码讲解



# 从本地python导入xtquant库，如果出现报错则说明安装失败

from xtquant import xtdata

import time



# 设定一个标的列表

code_list = ["000001.SZ"]

# 设定获取数据的周期

period = "1d"



# 下载标的行情数据

if 1:

    ## 为了方便用户进行数据管理，xtquant的大部分历史数据都是以压缩形式存储在本地的

    ## 比如行情数据，需要通过download_history_data下载，财务数据需要通过

    ## 所以在取历史数据之前，我们需要调用数据下载接口，将数据下载到本地

    for i in code_list:

        xtdata.download_history_data(i,period=period,incrementally=True) # 增量下载行情数据（开高低收,等等）到本地

    

    xtdata.download_financial_data(code_list) # 下载财务数据到本地

    xtdata.download_sector_data() # 下载板块数据到本地

    # 更多数据的下载方式可以通过数据字典查询



# 读取本地历史行情数据

history_data = xtdata.get_market_data_ex(,code_list,period=period,count=-1)

print(history_data)

print("=" * 20)



# 如果需要盘中的实时行情，需要向服务器进行订阅后才能获取

# 订阅后，get_market_data函数于get_market_data_ex函数将会自动拼接本地历史行情与服务器实时行情



# 向服务器订阅数据

for i in code_list:

    xtdata.subscribe_quote(i,period=period,count=-1) # 设置count = -1来取到当天所有实时行情



# 等待订阅完成

time.sleep(1)



# 获取订阅后的行情

kline_data = xtdata.get_market_data_ex(,code_list,period=period)

print(kline_data)



# 获取订阅后的行情，并以固定间隔进行刷新,预期会循环打印10次

for i in range(10):

    # 这边做演示，就用for来循环了，实际使用中可以用while True

    kline_data = xtdata.get_market_data_ex(,code_list,period=period)

    print(kline_data)

    time.sleep(3) # 三秒后再次获取行情



# 如果不想用固定间隔触发，可以以用订阅后的回调来执行

# 这种模式下当订阅的callback回调函数将会异步的执行，每当订阅的标的tick发生变化更新，callback回调函数就会被调用一次

# 本地已有的数据不会触发callback

    

# 定义的回测函数

    ## 回调函数中，data是本次触发回调的数据，只有一条

def f(data):

    # print(data)

    

    code_list = list(data.keys())    # 获取到本次触发的标的代码



    kline_in_callabck = xtdata.get_market_data_ex(,code_list,period = period)    # 在回调中获取klines数据

    print(kline_in_callabck)



for i in code_list:

    xtdata.subscribe_quote(i,period=period,count=-1,callback=f) # 订阅时设定回调函数



# 使用回调时，必须要同时使用xtdata.run()来阻塞程序，否则程序运行到最后一行就直接结束退出了。

xtdata.run()

#coding:utf-8

import time, datetime, traceback, sys

from xtquant import xtdata

from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback

from xtquant.xttype import StockAccount

from xtquant import xtconstant



#定义一个类 创建类的实例 作为状态的容器

class _a():

    pass

A = _a()

A.bought_list = 

A.hsa = xtdata.get_stock_list_in_sector('沪深A股')



def interact():

    """执行后进入repl模式"""

    import code

    code.InteractiveConsole(locals=globals()).interact()

xtdata.download_sector_data()



def f(data):

    now = datetime.datetime.now()

    for stock in data:

        if stock not in A.hsa:

            continue

        cuurent_price = data[stock]['lastPrice']

        pre_price = data[stock]['lastClose']

        ratio = cuurent_price / pre_price - 1 if pre_price > 0 else 0

        if ratio > 0.09 and stock not in A.bought_list:

            print(f"{now} 最新价 买入 {stock} 200股")

            async_seq = xt_trader.order_stock_async(acc, stock, xtconstant.STOCK_BUY, 200, xtconstant.LATEST_PRICE, -1, 'strategy_name', stock)

            A.bought_list.append(stock)

    

class MyXtQuantTraderCallback(XtQuantTraderCallback):

    def on_disconnected(self):

        """

        连接断开

        :return:

        """

        print(datetime.datetime.now(),'连接断开回调')



    def on_stock_order(self, order):

        """

        委托回报推送

        :param order: XtOrder对象

        :return:

        """

        print(datetime.datetime.now(), '委托回调', order.order_remark)





    def on_stock_trade(self, trade):

        """

        成交变动推送

        :param trade: XtTrade对象

        :return:

        """

        print(datetime.datetime.now(), '成交回调', trade.order_remark)





    def on_order_error(self, order_error):

        """

        委托失败推送

        :param order_error:XtOrderError 对象

        :return:

        """

        # print("on order_error callback")

        # print(order_error.order_id, order_error.error_id, order_error.error_msg)

        print(f"委托报错回调 {order_error.order_remark} {order_error.error_msg}")



    def on_cancel_error(self, cancel_error):

        """

        撤单失败推送

        :param cancel_error: XtCancelError 对象

        :return:

        """

        print(datetime.datetime.now(), sys._getframe().f_code.co_name)



    def on_order_stock_async_response(self, response):

        """

        异步下单回报推送

        :param response: XtOrderResponse 对象

        :return:

        """

        print(f"异步委托回调 {response.order_remark}")



    def on_cancel_order_stock_async_response(self, response):

        """

        :param response: XtCancelOrderResponse 对象

        :return:

        """

        print(datetime.datetime.now(), sys._getframe().f_code.co_name)



    def on_account_status(self, status):

        """

        :param response: XtAccountStatus 对象

        :return:

        """

        print(datetime.datetime.now(), sys._getframe().f_code.co_name)





if __name__ == '__main__':

    print("start")

    #指定客户端所在路径

    path = r'D:\qmt\sp3\迅投极速交易终端 睿智融科版\userdata_mini'

    # 生成session id 整数类型 同时运行的策略不能重复

    session_id = int(time.time())

    xt_trader = XtQuantTrader(path, session_id)

    # 开启主动请求接口的专用线程 开启后在on_stock_xxx回调函数里调用XtQuantTrader.query_xxx函数不会卡住回调线程，但是查询和推送的数据在时序上会变得不确定

    # 详见: http://docs.thinktrader.net/vip/pages/ee0e9b/#开启主动请求接口的专用线程

    # xt_trader.set_relaxed_response_order_enabled(True)



    # 创建资金账号为 800068 的证券账号对象

    acc = StockAccount('800068', 'STOCK')

    # 创建交易回调类对象，并声明接收回调

    callback = MyXtQuantTraderCallback()

    xt_trader.register_callback(callback)

    # 启动交易线程

    xt_trader.start()

    # 建立交易连接，返回0表示连接成功

    connect_result = xt_trader.connect()

    print('建立交易连接，返回0表示连接成功', connect_result)

    # 对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功

    subscribe_result = xt_trader.subscribe(acc)

    print('对交易回调进行订阅，订阅后可以收到交易主推，返回0表示订阅成功', subscribe_result)



    #这一行是注册全推回调函数 包括下单判断 安全起见处于注释状态 确认理解效果后再放开

    # xtdata.subscribe_whole_quote(["SH", "SZ"], callback=f)

    # 阻塞主线程退出

    xt_trader.run_forever()

    # 如果使用vscode pycharm等本地编辑器 可以进入交互模式 方便调试 （把上一行的run_forever注释掉 否则不会执行到这里）

    interact()

def get_all_market_code(ContextInfo):



    all_market_codes = [item for item in ContextInfo.get_stock_list_in_sector('沪深A股') if not item.endswith('BJ')]

    return filter_ST_stock(ContextInfo, all_market_codes)

    

    

def filter_ST_stock(ContextInfo, code_list):

    result = 

    for code in code_list:

        if re.search('(st)|(ST)|(\*st)|(\*ST)|(退)',ContextInfo.get_stock_name(code)):

            print('排除 ： ',ContextInfo.get_stock_name(code),code)

            continue

        result.append(code)

    return result

    

global_dict = {}



def init(ContextInfo):

    now = time.ctime()

    print('策略初始化{}'.format(now))

    need_download = 1

    global_dict['start_date'] = '20231201'

    global_dict['end_date'] = ''

    global_dict['code_list'] = get_all_market_code(ContextInfo)

    

# coding:gbk

import time





class G():

    pass





g = G()





def init(ContextInfo):

    g.hsa = [item for item in ContextInfo.get_stock_list_in_sector('沪深A股') if not item.endswith('BJ')]

    g.vol_dict = {}

    for stock in g.hsa:

        g.vol_dict[stock] = ContextInfo.get_last_volume(stock)

    ContextInfo.run_time("execution", "1nSecond", "2019-10-14 13:20:00")





def execution(ContextInfo):

    t0 = time.time()

    full_tick = ContextInfo.get_full_tick(g.hsa)

    total_market_value = 0

    total_ratio = 0

    count = 0

    for stock in g.hsa:

        if full_tick[stock]['lastClose'] == 0:

            continue

        ratio = full_tick[stock]['lastPrice'] / full_tick[stock]['lastClose'] - 1

        rise_price = round(full_tick[stock]['lastClose'] * 1.2, 2) if stock[0] == '3' or stock[:3] == '688' else round(

            full_tick[stock]['lastClose'] * 1.1, 2)

        # 如果要打印涨停品种

        if abs(full_tick[stock]['lastPrice'] - rise_price) <0.01:

            print(f"涨停股票 {stock} {ContextInfo.get_stock_name(stock)}")



        market_value = full_tick[stock]['lastPrice'] * g.vol_dict[stock]

        total_ratio += ratio * market_value

        total_market_value += market_value

        count += 1

    # print(count)

    total_ratio /= total_market_value

    total_ratio *= 100

    print(f'A股加权涨幅 {round(total_ratio, 2)}% 函数运行耗时{round(time.time() - t0, 5)}秒')

#-*-coding:gbk-*-

import datetime

code = '838402.BJ'

def init(ContextInfo):

    now = datetime.datetime.now()

    print(now)



def handlebar(ContextInfo):

    index = ContextInfo.barpos

    realtime = ContextInfo.get_bar_timetag(index)

    date = timetag_to_datetime(realtime, "%Y-%m-%d %H:%M:%S")

    info = ContextInfo.get_full_tick(stock_code=["838402.BJ"])

    print(info)

#-*-coding:gbk-*-

import datetime



code = '838402.BJ'

def init(ContextInfo):

    now = datetime.datetime.now()

    print(now)

    download_history_data(code,"1d","20240105","")



def handlebar(ContextInfo):

    index = ContextInfo.barpos

    realtime = ContextInfo.get_bar_timetag(index)

    date = timetag_to_datetime(realtime, "%Y-%m-%d %H:%M:%S")

    print(date)

    hist = ContextInfo.get_market_data_ex(['close'],[code], period = "1d",count = 1)

    print(hist)

import datetime 

import time



RUN_TIME = '09:24'



def execution(context):



    while 1:

        current_second = datetime.datetime.now().strftime('%S')

        if current_second >= '58':

            break

        time.sleep(0.1)



    do_something()



def initialize(context):

    # 初始化策略

    run_daily(context, execution, RUN_TIME)



def handle_data(context, data):

    pass

class a():

	pass

A = a()

class A():

	pass

a = A()

class GlobalCls():

    pass

    

g = GlobalCls()

文件编码声明： #coding:gbk 是指定源文件的编码格式为GBK。在Python 3中，通常使用UTF-8作为文件编码格式，因此可以将该行删除或更改为#coding:utf-8。



类名和函数名： 根据PEP 8命名约定，类名应该使用大写字母开头的驼峰命名法（例如A改为A）。同样，函数名应该使用小写字母开头的小写命名法（例如init改为init，f改为f）。



类和实例： 在代码中定义了一个空类a，但没有给它任何属性或方法。如果不需要这个类，可以将其删除。



缩进和代码格式： Python非常依赖于正确的缩进，以指示代码块的层次结构。请确保代码的缩进是一致的，并使用适当的缩进级别（通常是4个空格）。



代码注释： 代码中有一些注释，但是大部分是被注释掉的。良好的注释可以增加代码的可读性和可维护性，建议在关键部分添加更多有用的注释。



异常处理： 代码中没有包含任何异常处理机制。在实际应用中，建议对可能引发异常的操作进行适当的异常处理，以提高代码的健壮性。

		rise_price = round(full_tick[stock]['lastClose'] *1.2,2) if stock[0] == '3' or stock[:3] == '688' else round(full_tick[stock]['lastClose'] *1.1,2)

#-*-coding:gbk-*-

import time

start = False

ACCOUNT = ''



def init(ContextInfo):

    now = time.ctime()

    print(now)

    ContextInfo.run_time("execution","30nSecond","2023-04-14 13:20:00")





def execution(ContextInfo):

    data = ContextInfo.get_stock_list_in_sector('沪深A股')

    print(len(data))



def handlebar(ContextInfo):

    pass

【2023-10-25 15:18:45.533】  start trading mode

【2023-10-25 15:18:45.533】  Wed Oct 25 15:18:45 2023



【2023-10-25 15:18:45.533】  5074

['000001.SZ', '000002.SZ', '000004.SZ', '000005.SZ', '000006.SZ', '000007.SZ', '000008.SZ', '000009.SZ', '000010.SZ', '000011.SZ', '000012.SZ', '000014.SZ', '000016.SZ', '000017.SZ', '000019.SZ', '000020.SZ', '000021.SZ', '000023.SZ', '000025.SZ', '000026.SZ', '000027.SZ', '000028.SZ', '000029.SZ', '000030.SZ', '000031.SZ', '000032.SZ', '000034.SZ', '000035.SZ', '000036.SZ', '000037.SZ', '000039.SZ', '000040.SZ', '000042.SZ', '000045.SZ', '000046.SZ', '000048.SZ', '000049.SZ', '000050.SZ', '000055.SZ', '000056.SZ', '000058.SZ', '000059.SZ', '000060.SZ', '000061.SZ', '000062.SZ', '000063.SZ', '000065.SZ', '000066.SZ', '000068.SZ', '000069.SZ', '000070.SZ', '000078.SZ', '000088.SZ', '000089.SZ', '000090.SZ', '000096.SZ', '000099.SZ', '000100.SZ', '000151.SZ', '000153.SZ', '000155.SZ', '000156.SZ', '000157.SZ', '000158.SZ', '000159.SZ', '000166.SZ', '000301.SZ', '000333.SZ', '000338.SZ', '000400.SZ', '000401.SZ', '000402.SZ', '000403.SZ', '000404.SZ', '000407.SZ', '000408.SZ', '000409.SZ', '000410.SZ', '000411.SZ', '000413.SZ', '000415.SZ', '000416.SZ', '000417.SZ', '000419.SZ', '000420.SZ', '000421.SZ', '000422.SZ', '000423.SZ', '000425.SZ', '000426.SZ',