# 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）范围的订单会马上

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

队列

三、

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

然后报柜台

// ==UserScript==

// @name         去除博客导流公众号

// @namespace    http://tampermonkey.net/

// @version      1.0.0

// @description  去除openwrite“博客导流公众号”功能

// @author       You

// @include      http*://*

// @grant        none

// ==/UserScript==



(function() {

    'use strict';

   

    destroyBTWPlugin();



    function destroyBTWPlugin() {

        // 判断是否有插件

        const hasBTWPlugin = typeof BTWPlugin == "function"



        if (hasBTWPlugin) {

            // 获取属性

            const plugin = new BTWPlugin().options;

            if (plugin) {

                // 删除元素

                const read_more_wrap = document.getElementById("read-more-wrap")

                if (read_more_wrap) {

                    read_more_wrap.remove();

                }

                // 删除样式

                const ctner = document.getElementById(plugin.id)

                if (ctner) {

                    ctner.removeAttribute("style");

                }

            }

        }

    }

})();

// ==UserScript==

// @name         绕过openwrite公众号导流

// @namespace    http://tampermonkey.net/

// @version      1.6

// @description  去除openwrite“博客导流公众号”功能

// @author       GoodbyeNJN

// @license      GPLv3

// @match        *://*/*

// @grant        none

// ==/UserScript==



/**

 * openwrite 脚本基本逻辑：

 * 函数名和属性名储存在一个数组中(搜索“阅读全文”可定位到)，取值时通过对应的索引取出对应的值。

 * 先构造一个对象(搜索“const .* = function”可定位到)，在下方不远处给它的 prototype 上添加 options 和 init。

 * 点击弹窗中的“提交”按钮时，触发回调(搜索“alert”可定位到)，解析后具体代码如下：



 * function () {

 *     const val = $("#btw-modal-input").val();

 *     if (val === "") {

 *         alert("请输入校验码！");

 *         $("#btw-modal-input").focus();

 *         return;

 *     }

 *     const { blogId } = btw.options

 *     const api = "https://my.openwrite.cn/code/check";

 *     const url = "" + api + "?blogId=" + blogId + "&code=" + val + "";

 *     $.get(url, function (res) {

 *         if (res.result === true) {

 *             localStorage.setItem("TOKEN_" + blogId + "", blogId);

 *             $("#btw-modal-wrap, #read-more-wrap").remove();

 *             $("#" + btw.options.id + "").height("");

 *         } else {

 *             alert("校验码有误！");

 *         }

 *     });

 * }



 */



"use strict";



const READ_MORE_ID = "read-more-wrap";



/**

 * 判断是否存在插件

 */

const hasBtwPlugin = () => {

    const hasBTWPlugin = typeof BTWPlugin === "function";

    const hasJquery = typeof $ === "function";



    return hasBTWPlugin && hasJquery;

};



/**

 * 判断是否存在“阅读全文”按钮

 */

const hasReadMoreBtn = () => {

    return !!document.getElementById(READ_MORE_ID);

};



/**

 * 获取插件初始化选项

 */

const getOptions = () => {

    return (

        BTWPlugin.prototype.options || {

            id: "container",

            blogId: "",

            name: "",

            qrcode: "",

            keyword: "",

        }

    );

};



/**

 * 监听“阅读全文”按钮的出现

 * 用于首次触发该脚本且无按钮时，监听后续的按钮出现事件

 */

const listenReadMoreBtnShow = fn => {

    const observer = new MutationObserver(mutations =>

        mutations.forEach(mutation =>

            mutation.addedNodes.forEach(node => {

                if (node.id === READ_MORE_ID) {

                    observer.disconnect();

                    fn();

                }

            }),

        ),

    );



    const { id } = getOptions();

    const parent = document.getElementById(id);

    parent && observer.observe(parent, { childList: true });

};



/**

 * 监听部分 history 改动事件

 * 用于 spa 页面路由变化时自动展示全文

 */

const listenHistoryChange = fn => {

    const wrap = type => {

        const fn = history[type];

        return function (...args) {

            const res = fn.apply(this, args);

            const e = new Event(type);

            e.arguments = args;

            window.dispatchEvent(e);

            return res;

        };

    };



    history.pushState = wrap("pushState");

    history.replaceState = wrap("replaceState");



    window.addEventListener("replaceState", fn);

    window.addEventListener("pushState", fn);

    window.addEventListener("hashchange", fn);

};



/**

 * 展示全文

 */

const showHiddenText = () => {

    const { id, blogId } = getOptions();

    console.log("id:", id);

    localStorage.setItem(`TOKEN_${blogId}`, blogId);

    $(`#${READ_MORE_ID}`).remove();

    $(`#${id}`).height("");

};



(function () {

    if (!hasBtwPlugin()) {

        return;

    }



    $().ready(() => {

        listenHistoryChange(showHiddenText);



        if (hasReadMoreBtn()) {

            showHiddenText();

        } else {

            listenReadMoreBtnShow(showHiddenText);

        }

    });

})();

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

xtdata是xtquant库中提供行情相关数据的模块，本模块旨在提供精简直接的数据满足量化交易者的数

据需求，作为python库的形式可以被灵活添加到各种策略脚本中。

主要提供行情数据（历史和实时的K线和分笔）、财务数据、合约基础信息、板块和行业分类信息等通

用的行情数据

# 创建策略

#coding=utf-8

from xtquant.xttrader import XtQuantTrader, XtQuantTraderCallback

from xtquant.xtquant import StockAccount

from xtquant import xtconstant



class MyXtQuantTraderCallback(XtQuantTraderCallback):

    def on_disconnected(self):

        """

        连接断开

        :return:

        """

        print("connection lost")

    def on_stock_order(self, order):

        """

        委托回报推送

        :param order: XtOrder对象

        :return:

        """

        print("on order callback:")

        print(order.stock_code, order.order_status, order.order_sysid)

    def on_stock_asset(self, asset):

        """

        资金变动推送

        :param asset: XtAsset对象

        :return:

        """

        print("on asset callback")

        print(asset.account_id, asset.cash, asset.total_asset)

    def on_stock_trade(self, trade):

        """

        成交变动推送

        :param trade: XtTrade对象

        :return:

        """

        print("on trade callback")

        print(trade.account_id, trade.stock_code, trade.order_id)

    def on_stock_position(self, position):

        """

        持仓变动推送

        :param position: XtPosition对象

        :return:

        """

        print("on position callback")

        print(position.stock_code, position.volume)

    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)

    

    def on_cancel_error(self, cancel_error):

        """

        撤单失败推送

        :param cancel_error: XtCancelError 对象

        :return:

        """

        print("on cancel_error callback")

        print(cancel_error.order_id, cancel_error.error_id,

        cancel_error.error_msg)

    def on_order_stock_async_response(self, response):

        """

        异步下单回报推送

        :param response: XtOrderResponse 对象

        :return:

        """

        print("on_order_stock_async_response")

        print(response.account_id, response.order_id, response.seq)

    

if __name__ == "__main__":

    print("demo test")

    # path为mini qmt客户端安装目录下userdata_mini路径

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

    # session_id为会话编号，策略使用方对于不同的Python策略需要使用不同的会话编号

    session_id = 123456

    xt_trader = XtQuantTrader(path, session_id)

    

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

    acc = StockAccount('1000000365')

    

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

    callback = MyXtQuantTraderCallback()

    xt_trader.register_callback(callback)

    

    # 启动交易线程

    xt_trader.start()

    

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

    connect_result = xt_trader.connect()

    print(connect_result)

    

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

    subscribe_result = xt_trader.subscribe(acc)

    print(subscribe_result)

    stock_code = '600000.SH'

    

    # 使用指定价下单，接口返回订单编号，后续可以用于撤单操作以及查询委托状态

    print("order using the fix price:")

    fix_result_order_id = xt_trader.order_stock(acc, stock_code,

    xtconstant.STOCK_BUY, 200, xtconstant.FIX_PRICE, 10.5, 'strategy_name',

    'remark')

    print(fix_result_order_id)

    

    # 使用订单编号撤单

    print("cancel order:")

    cancel_order_result = xt_trader.cancel_order_stock(acc, fix_result_order_id)

    print(cancel_order_result)

    

    # 使用异步下单接口，接口返回下单请求序号seq，seq可以和on_order_stock_async_response

    的委托反馈response对应起来

    print("order using async api:")

    async_seq = xt_trader.order_stock(acc, stock_code, xtconstant.STOCK_BUY,

    200, xtconstant.FIX_PRICE, 10.5, 'strategy_name', 'remark')

    print(async_seq)

    

    # 查询证券资产

    

    print("query asset:")

    asset = xt_trader.query_stock_asset(acc)

    if asset:

        print("asset:")

        print("cash {0}".format(asset.cash))

        # 根据订单编号查询委托

        print("query order:")

    order = xt_trader.query_stock_order(acc, fix_result_order_id)

    if order:

        print("order:")

        print("order {0}".format(order.order_id))

        # 查询当日所有的委托

        print("query orders:")

        orders = xt_trader.query_stock_orders(acc)

        print("orders:", len(orders))

    

    if len(orders) != 0:

        print("last order:")

        print("{0} {1} {2}".format(orders[-1].stock_code,

        orders[-1].order_volume, orders[-1].price))

        # 查询当日所有的成交

        print("query trade:")

    trades = xt_trader.query_stock_trades(acc)

    print("trades:", len(trades))

    

    if len(trades) != 0:

        print("last trade:")

        print("{0} {1} {2}".format(trades[-1].stock_code,

        trades[-1].traded_volume, trades[-1].traded_price))

    # 查询当日所有的持仓

    print("query positions:")

    positions = xt_trader.query_stock_positions(acc)

    print("positions:", len(positions))

    

    if len(positions) != 0:

        print("last position:")

        print("{0} {1} {2}".format(positions[-1].account_id,

        positions[-1].stock_code, positions[-1].volume))

    

    # 根据股票代码查询对应持仓

    print("query position:")

    position = xt_trader.query_stock_position(acc, stock_code)

    if position:

        print("position:")

        print("{0} {1} {2}".format(position.account_id, position.stock_code,

        position.volume))

        # 阻塞线程，接收交易推送

    xt_trader.run_forever()

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)

def initialize(context):

    # 初始化策略

    g.code_mapper = date_code_mapper()

    log.info(g.code_mapper)

    g.error_set=set()

    

def last_n_day(date,n,origin_fmt,target_fmt):

    return (datetime.datetime.strptime(date, origin_fmt) - datetime.timedelta(days=n)).strftime(target_fmt)



def post_fix(code):

    return code + '.SZ' if code.startswith('12') else code + '.SS'

    

def handle_data(context, data):

    date=context.blotter.current_dt.strftime('%Y%m%d')

    if date not in g.code_mapper:

        return

    

    security_list=g.code_mapper.get(date)



    for code in security_list:

        code=post_fix(code)

        try:

            df = get_history(1, frequency='1m', field=['open' ,'high','low','close'], security_list=code, fq='pre',include=False)

        except Exception as e:

            if code not in g.error_set:

                log.info(e)

                log.info('代码获取数据 出错{}'.format(code))

                g.error_set.add(code)

            continue

        df['ticker']=code

        g.result.append(df)

    

def after_trading_end(context, data):

    #engine = DBS

    db = DBSelector()

    conn = db.get_engine()

    date=context.blotter.current_dt.strftime('%Y%m%d%H%M')

    if len(g.result)==0:

        return

        

    df = pd.concat(g.result)

    try:

        df.to_sql('minute_info',con=conn,if_exists='append')

    except Exception as e:

        log.info(e)

    

    g.result=



def before_trading_start(context, data):

    g.result=

In [1]: import datetime, aniso8601, iso8601, isodate, dateutil.parser, arrow, ciso8601



In [2]: ds = u'2014-01-09T21:48:00.921000'



In [3]: %timeit ciso8601.parse_datetime(ds)

1000000 loops, best of 3: 204 ns per loop



In [4]: %timeit datetime.datetime.strptime(ds, "%Y-%m-%dT%H:%M:%S.%f")

100000 loops, best of 3: 15 µs per loop



In [5]: %timeit dateutil.parser.parse(ds)

10000 loops, best of 3: 122 µs per loop



In [6]: %timeit aniso8601.parse_datetime(ds)

10000 loops, best of 3: 28.9 µs per loop



In [7]: %timeit iso8601.parse_date(ds)

10000 loops, best of 3: 42 µs per loop



In [8]: %timeit isodate.parse_datetime(ds)

10000 loops, best of 3: 69.4 µs per loop



In [9]: %timeit arrow.get(ds).datetime

10000 loops, best of 3: 87 µs per loop

In [1]: import datetime, aniso8601, iso8601, isodate, dateutil.parser, arrow, ciso8601



In [2]: ds = u'2014-01-09T21:48:00.921000+05:30'



In [3]: %timeit ciso8601.parse_datetime(ds)

1000000 loops, best of 3: 525 ns per loop



In [4]: %timeit dateutil.parser.parse(ds)

10000 loops, best of 3: 162 µs per loop



In [5]: %timeit aniso8601.parse_datetime(ds)

10000 loops, best of 3: 36.8 µs per loop



In [6]: %timeit iso8601.parse_date(ds)

10000 loops, best of 3: 53.5 µs per loop



In [7]: %timeit isodate.parse_datetime(ds)

10000 loops, best of 3: 82.6 µs per loop



In [8]: %timeit arrow.get(ds).datetime

10000 loops, best of 3: 104 µs per loop

Even with time zone information, ciso8601 is 70x as fast as aniso8601.

Tested on Python 2.7.10 on macOS 10.12.6 using the following modules:

      Collecting setuptools>=40.8.0

        WARNING: Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None)) after connection broken by 'ReadTimeoutError("HTTPSConnectionPool(host='files.pythonhosted.org', port=443): Read timed out. (read timeout=15)")': /packages/a4/53/bfc6409447ca024558b8b19d055de94c813c3e32c0296c48a0873a161cf5/setuptools-63.2.0-py3-none-any.whl

        Downloading setuptools-63.2.0-py3-none-any.whl (1.2 MB)

           ━━━━╸                                    0.1/1.2 MB 102.5 kB/s eta 0:00:11

      ERROR: Exception:

      Traceback (most recent call last):

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_vendor/urllib3/response.py", line 435, in _error_catcher

          yield

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_vendor/urllib3/response.py", line 516, in read

          data = self._fp.read(amt) if not fp_closed else b""

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_vendor/cachecontrol/filewrapper.py", line 90, in read

          data = self.__fp.read(amt)

        File "/home/xda/miniconda3/envs/cpy/lib/python3.9/http/client.py", line 462, in read

          n = self.readinto(b)

        File "/home/xda/miniconda3/envs/cpy/lib/python3.9/http/client.py", line 506, in readinto

          n = self.fp.readinto(b)

        File "/home/xda/miniconda3/envs/cpy/lib/python3.9/socket.py", line 704, in readinto

          return self._sock.recv_into(b)

        File "/home/xda/miniconda3/envs/cpy/lib/python3.9/ssl.py", line 1241, in recv_into

          return self.read(nbytes, buffer)

        File "/home/xda/miniconda3/envs/cpy/lib/python3.9/ssl.py", line 1099, in read

          return self._sslobj.read(len, buffer)

      socket.timeout: The read operation timed out

      

      During handling of the above exception, another exception occurred:

      

      Traceback (most recent call last):

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/cli/base_command.py", line 167, in exc_logging_wrapper

          status = run_func(*args)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/cli/req_command.py", line 205, in wrapper

          return func(self, options, args)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/commands/install.py", line 341, in run

          requirement_set = resolver.resolve(

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/resolution/resolvelib/resolver.py", line 94, in resolve

          result = self._result = resolver.resolve(

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_vendor/resolvelib/resolvers.py", line 481, in resolve

          state = resolution.resolve(requirements, max_rounds=max_rounds)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_vendor/resolvelib/resolvers.py", line 348, in resolve

          self._add_to_criteria(self.state.criteria, r, parent=None)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_vendor/resolvelib/resolvers.py", line 172, in _add_to_criteria

          if not criterion.candidates:

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_vendor/resolvelib/structs.py", line 151, in __bool__

          return bool(self._sequence)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/resolution/resolvelib/found_candidates.py", line 155, in __bool__

          return any(self)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/resolution/resolvelib/found_candidates.py", line 143, in <genexpr>

          return (c for c in iterator if id(c) not in self._incompatible_ids)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/resolution/resolvelib/found_candidates.py", line 47, in _iter_built

          candidate = func()

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/resolution/resolvelib/factory.py", line 215, in _make_candidate_from_link

          self._link_candidate_cache[link] = LinkCandidate(

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/resolution/resolvelib/candidates.py", line 291, in __init__

          super().__init__(

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/resolution/resolvelib/candidates.py", line 161, in __init__

          self.dist = self._prepare()

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/resolution/resolvelib/candidates.py", line 230, in _prepare

          dist = self._prepare_distribution()

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/resolution/resolvelib/candidates.py", line 302, in _prepare_distribution

          return preparer.prepare_linked_requirement(self._ireq, parallel_builds=True)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/operations/prepare.py", line 428, in prepare_linked_requirement

          return self._prepare_linked_requirement(req, parallel_builds)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/operations/prepare.py", line 473, in _prepare_linked_requirement

          local_file = unpack_url(

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/operations/prepare.py", line 155, in unpack_url

          file = get_http_url(

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/operations/prepare.py", line 96, in get_http_url

          from_path, content_type = download(link, temp_dir.path)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/network/download.py", line 146, in __call__

          for chunk in chunks:

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/cli/progress_bars.py", line 53, in _rich_progress_bar

          for chunk in iterable:

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_internal/network/utils.py", line 63, in response_chunks

          for chunk in response.raw.stream(

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_vendor/urllib3/response.py", line 573, in stream

          data = self.read(amt=amt, decode_content=decode_content)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_vendor/urllib3/response.py", line 538, in read

          raise IncompleteRead(self._fp_bytes_read, self.length_remaining)

        File "/home/xda/miniconda3/envs/cpy/lib/python3.9/contextlib.py", line 137, in __exit__

          self.gen.throw(typ, value, traceback)

        File "/tmp/pip-standalone-pip-oas0cddc/__env_pip__.zip/pip/_vendor/urllib3/response.py", line 440, in _error_catcher

          raise ReadTimeoutError(self._pool, None, "Read timed out.")

      pip._vendor.urllib3.exceptions.ReadTimeoutError: HTTPSConnectionPool(host='files.pythonhosted.org', port=443): Read timed out.

      [end of output]

  

  note: This error originates from a subprocess, and is likely not a problem with pip.

error: subprocess-exited-with-error

bolt-path = "/var/lib/influxdb/influxd.bolt"

engine-path = "/var/lib/influxdb/engine"

enable = true

#bind-address = ":8086"

$ influx -precision rfc3339

Error: unknown shorthand flag: 'p' in -precision

See 'influx -h' for help

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

history | awk '{CMD[$2]++;count++;}END { for (a in CMD)print CMD[a] " " CMD[a]/count*100 "% " a;}' | grep -v "./" | column -c3 -s " " -t | sort -nr | nl | head -n10

ERRO[0000] 'overlay' is not supported over overlayfs    

Error: error creating libpod runtime: 'overlay' is not supported over overlayfs: backing file system is unsupported for this graph driver

from flask import Flask, jsonify



# 最基本的测试



app =Flask(__name__)





@app.route('/about')

def about():

    return 'this is about page'



@app.route('/404')

def error_handle():

    return '404 error'



@app.route('/')

def error_handle():

    return jsonify({'code':100})







if __name__=='__main__':

    app.run(host='0.0.0.0',port=8001,debug=True)