from sqlalchemy import create_engine

ca_path = '/etc/ssl/certs/ca-certificates.crt' # linux 证书路径

ssl_args = {'ssl_ca': ca_path}



engine = create_engine('mysql+pymysql://root:password@127.0.01:3306/wordpressdb?charset=utf8', 

echo = True,

connect_args=ssl_args

)

/var/lib/influxdb/engine/data

sudo systemctl restart influxdb

update-rc.d influxdb remove

def split_order(code,direction,target_count):

    '''

    拆单

    :param code: 股票代码

    :param direction: 买：1 卖：-1

    :param target_count: 总共要卖的股数

    :return:

    '''



    SPLIT_ORDER_DELAY =1

    each_order_count = 100 # 每单的股数,张数

    count = int(target_count/each_order_count)

    remain_count = target_count%each_order_count



    for i in range(count):

        ret = order(code,direction*each_order_count)

        time.sleep(SPLIT_ORDER_DELAY)



    if direction==1:

        remain_count=int(remain_count/10)*10 # 可转债买的时候只能10的倍数交易，



    if remain_count>0:

        ret = order(code,direction*each_order_count)

    order(code,amount) # 买入或者卖出

    

    time.sleep(CANCEL_ORDER_TIME) # 等待片刻



    cancel_order_reorder(context) # 进入撤单函数

def initialize(context):

    g.security = '600570.SS'

    set_universe(g.security)



def handle_data(context, data):

    order(g.security,100)

    position = get_position(g.security)

    log.info(position)

def cancel_order_reorder(context):

    '''

    取消订单，重新下单

    :return:

    '''



    open_orders = get_open_orders()



    for _order in open_orders:

        _id = _order.id

        amount=_order.amount

        filled=_order.filled

        next_amount = amount-filled

        code = _order.symbol

        log.info('撤单{} - {}'.format(code,next_amount))

        cancel_order(_id)



        # time.sleep(1)

        log.info('重新下单{} 数量{}'.format(code,next_amount))

        order(code,next_amount)

import time

def initialize(context):

    # 初始化策略



    run_daily(context, get_price, '09:44')



def handle_data(context, data):

    pass

    

    

def get_price(context):

    for i in range(10):

        target_list =['113585.SS','123057.SZ']

        bond_gear_price_target = get_gear_price(target_list)

    

        for code in target_list:

            price = bond_gear_price_target[code]['offer_grp'][1][0]

            log.info('code: {} price {} '.format(code,price))

            

        time.sleep(1)

2022-09-28 10:31:00 - INFO - code: 113585.SS price 169.147 

2022-09-28 10:31:00 - INFO - code: 128053.SZ price 144.785 

2022-09-28 10:31:01 - INFO - code: 113585.SS price 169.147 

2022-09-28 10:31:01 - INFO - code: 128053.SZ price 144.785 

2022-09-28 10:31:02 - INFO - code: 113585.SS price 169.156 

2022-09-28 10:31:02 - INFO - code: 128053.SZ price 144.785 

2022-09-28 10:31:03 - INFO - code: 113585.SS price 169.156 

2022-09-28 10:31:03 - INFO - code: 128053.SZ price 144.8 

2022-09-28 10:31:04 - INFO - code: 113585.SS price 169.199 

2022-09-28 10:31:04 - INFO - code: 128053.SZ price 144.8 

2022-09-28 10:31:05 - INFO - code: 113585.SS price 169.199 

2022-09-28 10:31:05 - INFO - code: 128053.SZ price 144.8 

2022-09-28 10:31:06 - INFO - code: 113585.SS price 169.199 

2022-09-28 10:31:06 - INFO - code: 128053.SZ price 144.785 

2022-09-28 10:31:07 - INFO - code: 113585.SS price 169.068 

2022-09-28 10:31:07 - INFO - code: 128053.SZ price 144.785 

2022-09-28 10:31:08 - INFO - code: 113585.SS price 169.068 

2022-09-28 10:31:08 - INFO - code: 128053.SZ price 144.785 

2022-09-28 10:31:09 - INFO - code: 113585.SS price 169.068 

2022-09-28 10:31:09 - INFO - code: 128053.SZ price 144.746 

2022-09-28 10:31:10 - INFO - code: 113585.SS price 169.066 

2022-09-28 10:31:10 - INFO - code: 128053.SZ price 144.746 

2022-09-28 10:31:11 - INFO - code: 113585.SS price 169.066 

2022-09-28 10:31:11 - INFO - code: 128053.SZ price 144.746 

2022-09-28 10:31:12 - INFO - code: 113585.SS price 169.066 

2022-09-28 10:31:12 - INFO - code: 128053.SZ price 144.785 

2022-09-28 10:31:13 - INFO - code: 113585.SS price 169.068 

2022-09-28 10:31:13 - INFO - code: 128053.SZ price 144.785 

2022-09-28 10:31:14 - INFO - code: 113585.SS price 169.068 

2022-09-28 10:31:14 - INFO - code: 128053.SZ price 144.785 

2022-09-28 10:31:15 - INFO - code: 113585.SS price 169.068 

2022-09-28 10:31:15 - INFO - code: 128053.SZ price 144.692 

2022-09-28 10:31:16 - INFO - code: 113585.SS price 169.068 

2022-09-28 10:31:16 - INFO - code: 128053.SZ price 144.692 

2022-09-28 10:31:17 - INFO - code: 113585.SS price 169.068 

2022-09-28 10:31:17 - INFO - code: 128053.SZ price 144.692 

2022-09-28 10:31:18 - INFO - code: 113585.SS price 169.068 

2022-09-28 10:31:18 - INFO - code: 128053.SZ price 144.691 

2022-09-28 10:31:19 - INFO - code: 113585.SS price 169.062 

2022-09-28 10:31:19 - INFO - code: 128053.SZ price 144.691 

2022-09-28 10:31:20 - INFO - code: 113585.SS price 169.062 

2022-09-28 10:31:00 - INFO - code: 113585.SS price 169.147 



2022-09-28 10:31:01 - INFO - code: 113585.SS price 169.147 



2022-09-28 10:31:02 - INFO - code: 113585.SS price 169.156 



2022-09-28 10:31:03 - INFO - code: 113585.SS price 169.156 



2022-09-28 10:31:04 - INFO - code: 113585.SS price 169.199 



2022-09-28 10:31:05 - INFO - code: 113585.SS price 169.199 



2022-09-28 10:31:06 - INFO - code: 113585.SS price 169.199 



2022-09-28 10:31:07 - INFO - code: 113585.SS price 169.068 



2022-09-28 10:31:08 - INFO - code: 113585.SS price 169.068 



2022-09-28 10:31:09 - INFO - code: 113585.SS price 169.068 



2022-09-28 10:31:10 - INFO - code: 113585.SS price 169.066 



2022-09-28 10:31:11 - INFO - code: 113585.SS price 169.066 

pip install pillow

# coding=utf-8

from PIL import Image

import math



key = 3.2# 修改key值可以调整国旗的范围，推荐2~4之间的数字，支持小数

motherland_flag = Image.open('flag-1024.png')

head_picture = Image.open('mmexport1663893338571.png')

# 截图国旗上的五颗五角星

flag_width, flag_height = motherland_flag.size

crop_flag = motherland_flag.crop((66, 0, flag_height+66, flag_height))

# 将国旗截图处理成颜色渐变

for i in range(flag_height):

    for j in range(flag_height):

            color = crop_flag.getpixel((i, j))

            distance = int(math.sqrt(i*i + j*j))

            alpha = 255 - int(distance//key)

            new_color = (*color[0:-1], alpha if alpha > 0 else 0)

            crop_flag.putpixel((i, j), new_color)

# 修改渐变图片的尺寸，适应头像大小，粘贴到头像上

new_crop_flag = crop_flag.resize(head_picture.size)

head_picture.paste(new_crop_flag, (0, 0), new_crop_flag)

# 保存自己的国旗头像

head_picture.save('国旗头像.png')

代码介绍：



导入需要使用的Python库，pillow库用于对图片进行截取、大小修改、粘贴等处理。math库用于计算像素点的距离。



使用Image.open()方法，读取准备好的国旗图片和头像图片到代码中。



对国旗图片进行截取，获取一张正方形的图片，截取时调整截取位置，保证5颗五角星完整展示在截图中。



crop()方法中传入的是一个(left, upper, right, lower)的元组，分别是截图的左、上、右、下像素位置。

将正方形国旗截图设置成透明度渐变的图片。国旗图片的模式默认是RGBA，本文需要的刚好是RGBA(red,green,blue,alpha)模式的图片，RGBA模式的图片颜色值是一个长度为4的元组，我们修改不同像素点的A值即可将图片设置成渐变。



本文是以国旗左上角为圆心，离圆心越远的像素点A值越小，像素点越透明。使用getpixel()和putpixel()两个方法来获取和重设像素点的颜色值，使用math.sqrt()计算像素点距离。



将渐变图片的大小转换成和头像的大小一样，然后粘贴到图片顶层。使用resize()方法重设图片大小，使用paste()方法粘贴图片。



保存图片，此时的微信头像图片上已经粘贴了透明渐变的国旗图片，微信国旗头像制作完成。

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()

sudo snap install wechat-devtools

另外，此次沪市还调整了可转债交易及其约定购回式债券交易经手费收费标准，由原来按成交金额的0.0001%双向收取、单笔最高不超过100元，调整为按成交金额的0.004%双向收取。

du . -h --max-depth=1

du /Weixin/ -h --max-depth=3

$ ./q

KDB+ 4.0 2022.05.11 Copyright (C) 1993-2022 Kx Systems

l64/ 4()core 23934MB xda xda-linux 127.0.1.1   



'licence error: k4.lic

$ ./q -p 5001

KDB+ 4.0 2022.05.11 Copyright (C) 1993-2022 Kx Systems

l64/ 4(24)core 23934MB xda xda-linux 127.0.1.1 EXPIRE 2023.07.18 xxxxx@126.com KXCE #



'2022.09.04T11:34:18.272 couldn't connect to license daemon -- exiting

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