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}, 可以关注套利。 公众号：可转债量化分析')

def notify(content=''):

    send_qywx(

        '微信id', '微信key', 'agent', info=content, 

        touser= '你的微信名字', 

        )

        

def before_trading_start(context, data):

    now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')

    notify('Ptrade 盘前运行{}'.format(now))

    

class DBSelector():

    '''

    数据库选择类

    '''



    def get_engine(self):



        from sqlalchemy import create_engine

        try:

            engine = create_engine(

                'mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'.format(USER, PASSWORD, MYSQL_HOST, MYSQL_PORT, MYSQL_DB))

        except Exception as e:

            log.error(e)

            return None



        return engine



    def get_mysql_conn(self, db):

        import pymysql

        try:

            conn = pymysql.connect(host=MYSQL_HOST, port=MYSQL_PORT, user=USER, password=PASSWORD, db=db,

                                   charset='utf8')

        except Exception as e:

            log.error(e)

            return None

        else:

            return conn



def main():

    now = datetime.datetime.now()

    if not now.weekday():

        print('not week day')

        return



    db = DBSelector()

    conn = db.get_mysql_conn('ptrade')

    cursor = conn.cursor()

    sql_str = 'select count(*) from `ptrade_runing_status` where `date`=%s limit 1'

    date = now.strftime('%Y-%m-%d')

    cursor.execute(sql_str, (date,))

    result = cursor.fetchone()

    if result[0] == 0:

        send_message_via_wechat('{} ptrade没有启动！'.format(now))



if __name__=='__main__':

    main()

class DataFeed:

    def __init__(self):

        self.csv_path = CSV_PATH

        self.position = {}

        self.HighValue = 0

        self.Start_Cash = 1000000  # 初始资金

        self.MyCash = self.Start_Cash

        self.Withdraw = 0

        self.daily_netvalue = 

        self.current_day = 0

        self.PosValue = 0

        self.threshold = 0  # 阈值

        self.HighValue = self.Start_Cash

        self.date_list, self.source = self.feed()

        self.day_count = 0



    def unpossibile(self, df, date):

        # 剔除当日涨停的转债，买不入

        raise_limited_dict = {

            '2022-04-08': ['127057', ],

            '2022-07-27': ['127065', ],

            '2022-07-28': ['127065', ],

        }

        target_list = raise_limited_dict.get(date, None)

        if target_list is None:

            return df



        return df.drop(index=target_list, axis=1)



    def feed(self):

        df = pd.read_csv(self.csv_path,

                         encoding='utf8',

                         dtype={'tickerEqu': str, 'tickerBond': str, 'secID_x': str},

                         )

        del df['Unnamed: 0']

        df['tradeDate'] = pd.to_datetime(df['tradeDate'], format='%Y-%m-%d')

        df = df.set_index('tradeDate')

        date_set = set(df.index.tolist())

        date_list = list(map(lambda x: x.strftime('%Y-%m-%d'), date_set))

        date_list.sort()

        return date_list, df



    def filters(self, df, today):

        # 过滤条件，可添加多个条件

        df = self.unpossibile(df, today)

        return df



    def logprint(self, current):

        log.info('当前日期{}'.format(current))



    def run(self):

        for current in self.date_list:



            if current < START_DATE or current > END_DATE:

                continue



            if self.day_count % FREQ != 0:

                self.get_daily_netvalue(current)

            else:

                self.handle_data(current)



            self.day_count += 1



        self.after_trade()

pip install pytdx

from pytdx.hq import TdxHq_API

api = TdxHq_API()

with api.connect('119.147.212.81', 7709):

    data = api.get_security_bars(7, 0, '123045', 0, 240) # 123045 为转债代码 ，240 为获取 240个转债数据

    df = api.to_df(data)

    df=df.sort_values('datetime')

比如我的通达信客户端安装在 c:\new_tdx 下，



即



c:\new_tdx\vipdoc\sz\lday\ 下是深圳的日k线数据

c:\new_tdx\vipdoc\sh\lday\ 下是上海的日k线数据

c:\new_tdx\vipdoc\sh\minline\ 下是上海的分钟线数据

c:\new_tdx\vipdoc\sz\minline\ 下是深圳的分钟线数据

        from pytdx.reader import TdxMinBarReader

        path='/home/xda/Downloads/sz128014.lc1'

        reader = TdxMinBarReader()

        df = reader.get_df(path)

        #df.to_excel('tick.xlsx') # 导出为excel

api = TdxHq_API()

api = api.connect('119.147.212.81', 7709)

data=api.get_k_data('123045', '2020-05-01', '2022-08-26') # 123045 为可转债代码，可以替换任意代码

data.to_excel('k-line.xlsx')

from pytdx.hq import TdxHq_API

api = TdxHq_API()

with api.connect('119.147.212.81', 7709):

    data = api.get_security_bars(7, 0, '123045', 0, 240) # 123045 为转债代码 ，240 为获取 240个转债数据

    df = api.to_df(data)

    df=df.sort_values('datetime')

# ptrade软件-量化-回测 里，新建策略，复制全文粘贴进去，周期选分钟，再到交易里新增交易



import time



def reverse_repurchase(context):

    cash = context.portfolio.cash

    amount = int(cash/1000)*10

    log.info(amount)

    order('131810.SZ', -1*amount) # 深圳逆回购，

    



def ipo(context):

    ipo_stocks_order()

    



def initialize(context):

    g.flag = False

    log.info("initialize g.flag=" + str(g.flag) )

    run_daily(context, reverse_repurchase, '14:57')

    run_daily(context, ipo, '13:30')

    

def before_trading_start(context, data):

    pass

    

def handle_data(context, data):

    pass



def on_order_response(context, order_list):

    # 该函数会在委托回报返回时响应

    log.info(order_list)

def initialize(context):

    run_daily(context, get_trade_cb_list, "9:25")





def before_trading_start(context, data):

    # 每日清空，避免取到昨日市场代码表

    g.trade_cb_list = 





def handle_data(context, data):

    pass





# 获取当天可交易的可转债代码列表

def get_trade_cb_list(context):

    cb_list = get_cb_list()

    cb_snapshot = get_snapshot(cb_list)

    # 代码有行情快照并且交易状态不在暂停交易、停盘、长期停盘、退市状态的判定为可交易代码

    g.trade_cb_list = [cb_code for cb_code in cb_list if

                       cb_snapshot.get(cb_code, {}).get("trade_status") not in

                       [None, "HALT", "SUSP", "STOPT", "DELISTED"]]

    log.info("当天可交易的可转债代码列表为：%s" % g.trade_cb_list)

class Test(object):

    count = 5



    def print_info(self):

        self.count += 1

        log.info("a" * self.count)





def initialize(context):

    g.security = "600570.SS"

    set_universe(g.security)

    # 初始化无法被序列化类对象，并赋值为私有变量，落地持久化信息时跳过保存该变量

    g.__test_class = Test()



def handle_data(context, data):

    # 调用私有变量中定义的方法

    g.__test_class.print_info()

_pickle.PickingError: Can't pick <class 'IOEngine.user_module : attribute loopup

def get_tick(code, start_time, end_time, period='tick'):

    from xtquant import xtdata



    xtdata.download_history_data(code, period=period, start_time=start_time, end_time=end_time)

    data = xtdata.get_local_data(field_list=, stock_code=

, period=period, count=10)

    result_list = data

    df = pd.DataFrame(result_list)



    df['time_str'] = df['time'].apply(lambda x: datetime.datetime.fromtimestamp(x / 1000.0))

    return df

order_target 接口通过持仓数量比较将入参的目标数量转换成需要交易的成交，传入 order

接口



order_value 接口通过 金额/限价 或者 金额/默认最新价 两种方式转换成需要交易的数量，

传入 order 接口



order_target_value 接口通过持仓金额比较得到需要交易的金额， 金额/限价 或者 金额/默

认最新价 两种方式转换成需要交易的数量，传入 order 接口

order 接口：

一、

先判断 limit_price 是否传入，传入则用传入价格限价，不传入则最新价代替，都是

限价方式报单。

二、

判断隔夜单和交易时间，交易时间（9:10（系统可配）~15:00）范围的订单会马上

加入未处理订单队列，其他订单先放到一个队列，等时间到交易时间就放到未处理订单

队列

三、

未处理订单队列的订单会进行限价判断，如果没有传入限价就按当前最新价处理，

然后报柜台

Bond_Volatility_ENABLE = True

Bond_Volatility_DAYS = 30

TOP_RIPPLE = 50

Bond_Volatility_LOG_ENABLE = True  # 波动率日志开关

# 基类

class ConditionFilter:



    def filters(self, *args, **kwargs):

        if self.enable:

            return self.fun(*args, **kwargs)

        else:

            return True



    def fun(self, *args, **kwargs):

        # 继承的实现这个函数

        raise NotImplemented

# 权重 溢价率、转债价格、正股Ｎ天涨幅，正股ＲＯＥ

weights = {'溢价率': 0, '转债价格': 1, '正股N天涨幅': 0, '正股ROE': 0, '规模': 0}

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每天9:23分运行集合竞价处理函数

    run_daily(context, aggregate_auction_func, time='9:23')  



def aggregate_auction_func(context):

    stock = g.security

    #最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    #涨停价

    up_limit = snapshot[stock]['up_px']

    #如果最新价不小于涨停价，买入

    if float(price) >= float(up_limit):

        order(g.security, 100, limit_price=up_limit)

    

def handle_data(context, data):

    pass

def initialize(context):

    # 初始化此策略

    # 设置我们要操作的股票池, 这里我们只操作一支股票

    g.security = '600570.SS'

    set_universe(g.security)

    #每天9:23分运行集合竞价处理函数

    run_daily(context, aggregate_auction_func, time='9:23')

def aggregate_auction_func(context):

    stock = g.security

    #最新价

    snapshot = get_snapshot(stock)

    price = snapshot[stock]['last_px']

    #涨停价

    up_limit = snapshot[stock]['up_px']

    #如果最新价不小于涨停价，买入

    if float(price) >= float(up_limit):

        order(g.security, 100, limit_price=up_limit)

order-按数量买卖

order(security, amount, limit_price=None)

买卖标的。



注意：



由于下述原因，回测中实际买入或者卖出的股票数量有时候可能与委托设置的不一样，针对上述内容调整，系统会在日志中增加警告信息：



根据委托买入数量与价格经计算后的资金数量，大于当前可用资金；

委托卖出数量大于当前可用持仓数量；

每次交易数量只能是100的整数倍，但是卖出所有股票时不受此限制；

股票停牌、股票未上市或者退市、股票不存在；

回测中每天结束时会取消所有未完成交易；

order_target(security, amount, limit_price=None)

买卖股票，直到股票最终数量达到指定的amount。



注意：该函数在委托股票时取整100股，委托可转债时取整100张。



参数

security: 股票代码(str)；



amount: 期望的最终数量(int)；



limit_price：买卖限价(float)；



返回

Order对象中的id或者None。如果创建订单成功，则返回Order对象的id，失败则返回None(str)。

order_value - 指定目标价值买卖

order_value(security, value, limit_price=None)

买卖指定价值为value的股票。



注意：该函数在委托股票时取整100股，委托可转债时取整100张。

order_target_value - 指定持仓市值买卖

order_target_value(security, value, limit_price=None)

调整股票仓位到value价值



注意：该函数在委托股票时取整100股，委托可转债时取整100张。

order_market - 按市价进行委托

order_market(security, amount, market_type=None, limit_price=None)

可以使用多种市价类型进行委托。



注意：该函数仅在股票交易模块可用。

tick_data（可选）

tick_data(context, data)

该函数会每隔3秒执行一次。



注意 ：



该函数仅在交易模块可用。



该函数在9:30之后才能执行。



该函数中只能使用order_tick进行对应的下单操作。

order_tick(sid, amount, priceGear='1', limit_price=None)

买卖股票下单，可设定价格档位进行委托



注意：该函数仅在交易模块可用。



参数

sid：股票代码(str)；



amount：交易数量，正数表示买入，负数表示卖出(int)



priceGear：盘口档位，level1:1~5买档/-1~-5卖档，level2:1~10买档/-1~-10卖档(str)



limit_price：买卖限价，当输入参数中也包含priceGear时，下单价格以limit_price为主(float)；

def initialize(context):

    g.security = "600570.SS"

    set_universe(g.security)



def tick_data(context,data):

    security = g.security

    current_price = eval(data[security]['tick']['bid_grp'][0])[1][0]

    if current_price > 56 and current_price < 57:

        # 以买一档下单

        order_tick(g.security, -100, "1")

        # 以卖二档下单

        order_tick(g.security, 100, "-2")

        # 以指定价格下单

        order_tick(g.security, 100, limit_price=56.5)



def handle_data(context, data):

    pass

import time



def initialize(context):

	g.flag = False

	log.info("initialize g.flag=" + str(g.flag) )



def before_trading_start(context, data):

	g.flag = False

	log.info("before_trading_start g.flag=" + str(g.flag) )

    

def handle_data(context, data):

	if not g.flag and time.strftime("%H:%M:%S", time.localtime()) > '09:35:00':

		# 自动打新

		log.info("自动打新")

		ipo_stocks_order()

		g.flag = True



def on_order_response(context, order_list):

	# 该函数会在委托回报返回时响应

	log.info(order_list)

result = df.resample('3S',).first().ffill()