$ git clone https ://github.com/AUTOMATIC1111/stable-diffusion-webui.git



$ cd stable-diffusion-webui



$ git checkout 22bcc7be428c94e9408f589966c2040187245d81



# 我们需要 CPU 版本的 torch

$ export TORCH_COMMAND="pip install torch==1.13.1 torchvision==0.14.1 --index-url https: //download.pytorch.org/whl/cpu"

$ export USE_NNPACK=0



# 前 4 个参数是为了让其运行在 CPU 上, 最后一个参数是让 WebUI 可以远程访问

$ bash webui.sh --skip-torch-cuda-test --no-half --precision full --use-cpu all --listen

Stable Diffusion 是一种通过文字描述创造出图像的 AI 模型. 它是一个开源软件, 有许多人愿意在网络上免费分享他们的计算资源, 使得新手可以在线尝试.

$ dd if=/dev/zero of=/mnt/swap bs=64M count=256

$ chmod 0600 /mnt/swap

$ mkswap /mnt/swap

$ swapon /mnt/swap

bash webui.sh --skip-torch-cuda-test --no-half --precision full --use-cpu all --listen

$ cd models/Stable-diffusion​

# Stable diffusion v1.4

# 下面的URL超链接过长有省略号，需要右键复制url

$ wget https://huggingface.co/CompVis ... .ckpt

# Stable diffusion v1.5

$ wget https://huggingface.co/runwaym ... .ckpt

# F222

$ wget https://huggingface.co/acheong ... .ckpt

# Anything V3

$ wget 

https://huggingface.co/Linaqru ... nsors

# Open Journey

$ wget https://huggingface.co/prompth ... .ckpt

# DreamShaper

$ wget https://civitai.com/api/download/models/5636 -O dreamshaper_331BakedVae.safetensors

# ChilloutMix

$ wget https://civitai.com/api/download/models/11745 -O chilloutmix_NiPrunedFp32Fix.safetensors

# Robo Diffusion

$ wget 

https://huggingface.co/nousr/r ... .ckpt

# Mo-di-diffusion

$ wget 

https://huggingface.co/nitroso ... .ckpt

# Inkpunk Diffusion

$ wget 

https://huggingface.co/Envvi/I ... .ckpt

{

    "txt2img/Batch size/value": 4,

    "txt2img/Width/value": 480,

    "txt2img/Height/value": 270

}

model: chilloutmix_NiPrunedFp32Fix.safetensors



prompt: beautiful, masterpiece, best quality, extremely detailed face, perfect lighting, (1girl, solo, 1boy, 1girl, NemoNelly, Slight penetration, lying, on back, spread legs:1.5), street, crowd, ((skinny)), ((puffy eyes)), brown hair, medium hair, cowboy shot, medium breasts, swept bangs, walking, outdoors, sunshine, light_rays, fantasy, rococo, hair_flower,low tied hair, smile, half-closed eyes, dating, (nude), nsfw, (heavy breathing:1.5), tears, crying, blush, wet, sweat, <lora:koreanDollLikeness_v15:0.4>, <lora:povImminentPenetration_ipv1:0>, <lora:breastinclassBetter_v14:0.1>

prompt: paintings, sketches, (worst quality:2), (low quality:2), (normal quality:2), lowres, normal quality, ((monochrome)), ((grayscale)), skin spots, acnes, skin blemishes, age spot, (ugly:1.331), (duplicate:1.331), (morbid:1.21), (mutilated:1.21), (tranny:1.331), mutated hands, (poorly drawn hands:1.331), blurry, (bad anatomy:1.21), (bad proportions:1.331), extra limbs, (disfigured:1.331), (missing arms:1.331), (extra legs:1.331), (fused fingers:1.61051), (too many fingers:1.61051), (unclear eyes:1.331), bad hands, missing fingers, extra digit, bad body, pubic

$ cd models/Lora



$ wget 

https://huggingface.co/amornln ... nsors

$ wget 

https://huggingface.co/samle/s ... nsors

$ wget https://huggingface.co/jomcs/N ... nsors

用法： ContextInfo.get_market_data(fields, stock_code = , start_time = '', 

end_time = '', skip_paused = True, period = 'follow', 

dividend_type = 'follow', count = -1)

open -- 开盘价(str:numpy.float64)；

high -- 最高价(str:numpy.float64)；

low --最低价(str:numpy.float64)；

close -- 收盘价(str:numpy.float64)；

volume -- 交易量(str:numpy.float64)；

money -- 交易金额(str:numpy.float64)；

price -- 最新价(str:numpy.float64)；

preclose -- 昨收盘价(str:numpy.float64)(仅日线返回)；

high_limit -- 涨停价(str:numpy.float64)(仅日线返回)；

low_limit -- 跌停价(str:numpy.float64)(仅日线返回)；

unlimited -- 判断查询日是否无涨跌停限制(1：该日无涨跌停限制；0：该日有涨跌停限制)(str:numpy.float64)(仅日线返回)；

1. 涨停板；依赖ptrade的高速行情自动配合手动；
2. 两融账户的股票日内做T，持有底仓；
3. 股票小市值轮动+多因子
4. 可转债多因子（有N个版本+不同的排除因子 组合）
5. 可转债日内高频
6. 股票趋势动量
7. ETF轮动套利
8. 脉冲卖出扫描

margin_trade - 担保品买卖



margincash_open - 融资买入



margincash_close - 卖券还款



margincash_direct_refund - 直接还款



marginsec_open - 融券卖出



marginsec_close - 买券还券

2023-03-31 14:41:02 - INFO - 生成订单，订单号：cd25d27f39854721aac99db13c9e9b73股票代码：601328.SS 数量：信用买入1000

2023-03-31 14:41:02 - INFO - {'error_info': '', 'stock_code': '601328.SS', 'order_id': 'cd25d27f39854721aac99db13c9e9b73', 'status': '2', 'price': 5.1, 'entrust_type': '9', 'amount': 1000, 'business_amount': 0.0, 'entrust_prop': '0', 'entrust_no': '1', 'order_time': '2023-03-31 14:35:53.776'}

2023-03-31 14:41:02 - INFO - {'business_amount': 1000, 'order_id': 'cd25d27f39854721aac99db13c9e9b73', 'stock_code': '601328.SS', 'entrust_bs': '1', 'entrust_no': '1', 'status': '8', 'business_balance': 5100.0, 'business_price': 5.1, 'business_id': '2', 'business_time': '2023-03-31 14:39:17'}

2023-03-31 14:52:00 - INFO - 生成订单，订单号：01b7851d37014709bde3ec6ebe9e89c3股票代码：601328.SS 数量：融资买入100

2023-03-31 14:52:00 - INFO - {'price': 5.1, 'entrust_prop': '0', 'status': '2', 'entrust_type': '6', 'stock_code': '601328.SS', 'business_amount': 0.0, 'entrust_no': '3', 'order_time': '2023-03-31 14:46:51.620', 'error_info': '', 'amount': 100, 'order_id': '01b7851d37014709bde3ec6ebe9e89c3'}

2023-03-31 14:52:00 - INFO - {'business_id': '4', 'business_balance': 509.99999999999994, 'business_price': 5.1, 'order_id': '01b7851d37014709bde3ec6ebe9e89c3', 'business_time': '2023-03-31 14:50:14', 'status': '8', 'entrust_bs': '1', 'business_amount': 100, 'entrust_no': '3', 'stock_code': '601328.SS'}

2023-03-31 14:58:20 - INFO - start

2023-03-31 14:59:00 - INFO - 生成订单，订单号：20cef28ec52c4d41b09c80fc49167497股票代码：600269.SS 数量：卖券还款-200

2023-03-31 14:59:00 - INFO - {'business_amount': 0.0, 'amount': -200, 'stock_code': '600269.SS', 'error_info': '', 'order_time': '2023-03-31 14:53:51.375', 'price': 3.38, 'entrust_type': '6', 'status': '2', 'order_id': '20cef28ec52c4d41b09c80fc49167497', 'entrust_prop': '0', 'entrust_no': '5'}

2023-03-31 14:59:00 - INFO - {'status': '8', 'business_time': '2023-03-31 14:57:14', 'stock_code': '600269.SS', 'entrust_bs': '2', 'business_id': '6', 'business_balance': -676.0, 'business_amount': -200, 'order_id': '20cef28ec52c4d41b09c80fc49167497', 'business_price': 3.38, 'entrust_no': '5'}

def initialize(context):

    # 初始化策略

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

    g.security = "600300.SS"

    set_universe(g.security)



def before_trading_start(context, data):

    # 买入标识

    g.order_buy_flag = False

    # 卖出标识

    g.order_sell_flag = False



#当五日均线高于十日均线时买入，当五日均线低于十日均线时卖出

def handle_data(context, data):

    # 得到十日历史价格

    df = get_history(10, "1d", "close", g.security, fq=None, include=False)

    # 得到五日均线价格

    ma5 = round(df["close"][-5:].mean(), 3)

    # 得到十日均线价格

    ma10 = round(df["close"][-10:].mean(), 3)

    # 取得昨天收盘价

    price = data[g.security]["close"]

    # 如果五日均线大于十日均线

    if ma5 > ma10:

        if not g.order_buy_flag:

            # 获取最大可融资数量

            amount = get_margincash_open_amount(g.security).get(g.security)

            # 进行融资买入操作

            margincash_open(g.security, amount)

            # 记录这次操作

            log.info("Buying %s Amount %s" % (g.security, amount))

            # 当日已融资买入

            g.order_buy_flag = True



    # 如果五日均线小于十日均线，并且目前有头寸

    elif ma5 < ma10 and get_position(g.security).amount > 0:

        if not g.order_sell_flag:

            # 获取标的卖券还款最大可卖数量

            amount = get_margincash_close_amount(g.security).get(g.security)

            # 进行卖券还款操作

            margincash_close(g.security, -amount)

            # 记录这次操作

            log.info("Selling %s Amount %s" % (g.security, amount))

            # 当日已卖券还款

            g.order_sell_flag = True

担保品卖出指的是融资融券交易当中，用自有资金进行买卖的行为

def initialize(context):

    g.security = '600570.SS'

    set_universe(g.security)



def handle_data(context, data):

    # 以系统最新价委托

    margin_trade(g.security, 100)

    # 以72块价格下一个限价单

    margin_trade(g.security, 100, limit_price=72)

    # 以最优五档即时成交剩余撤销委托

    margin_trade(g.security, 200, market_type=4)

security：股票代码(str)；



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



limit_price：买卖限价(float)；



market_type：市价委托类型，上证非科创板股票支持参数1、4，上证科创板股票支持参数0、1、2、4，深证股票支持参数0、2、3、4、5(int)；



0：对手方最优价格；

1：最优五档即时成交剩余转限价；

2：本方最优价格；

3：即时成交剩余撤销；

4：最优五档即时成交剩余撤销；

5：全额成交或撤单；

Python path configuration:

  PYTHONHOME = (not set)

  PYTHONPATH = (not set)

  program name = 'python'

  isolated = 0

  environment = 1

  user site = 1

  import site = 1

  sys._base_executable = '\u0158\x06'

  sys.base_prefix = '.'

  sys.base_exec_prefix = '.'

  sys.executable = '\u0158\x06'

  sys.prefix = '.'

  sys.exec_prefix = '.'

  sys.path = [

    'C:\\anaconda\\python38.zip',

    '.\\DLLs',

    '.\\lib',

    '',

  ]

Fatal Python error: init_fs_encoding: failed to get the Python codec of the filesystem encodin

Python runtime state: core initialized

ModuleNotFoundError: No module named 'encodings'



Current thread 0x000013a8 (most recent call first):

import pandas as pd

import datetime





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





def process_timestamp(df, filename):

    df = df.set_index('time_str')

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

    # result = result[(result.index >= '2022-07-20 09:30') & (result.index <= '2022-07-20 15:00')]

    result = result.reset_index()

    result.to_csv(filename + '.csv')





def dump_single_code_tick():

    # 导出单个转债的tick数据

    code='128022'

    start_date = '20210113'

    end_date = '20210130'



    post_fix = 'SZ' if code.startswith('12') else 'SH'

    code = '{}.{}'.format(code,post_fix)

    filename = '{}'.format(code)

    df = get_tick(code, start_date, end_date)

    process_timestamp(df, filename)



dump_single_code_tick()

import (

    "fmt"

    "os/exec"

)



func runCommand(command string) (string, error) {

    cmd := exec.Command("sh", "-c", command)

    output, err := cmd.CombinedOutput()

    if err != nil {

        return "", err

    }

    return string(output), nil

}

docker update --restart=no <容器ID或名称>

docker restart <容器ID或名称>

ChatGPT 镜像网站汇总

BAI Chat GPT3.5 免登录 https://chat.theb.ai



ChatGPT GPT3.5 免登录 https://www.aitoolgpt.com/



Chat For AI GPT3.5 免登录，限制5次提问 https://chatforai.com/



ChatGPT Web GPT3.5 免登录 https://freechatgpt.chat/



ChatGPT GPT3.5 免登录 https://fastgpt.app/



光速Ai GPT3.5 免登录，限制 https://ai.ls



ChatGPT演示 GPT3.5 免登录 https://chatgpt.ddiu.me/



免费GPT GPT3.5 免登录 https://freegpt.one/



FreeGPT GPT3.5 免登录 https://freegpt.cc



ChatGPT Hub GPT3.5 免费100次，Plus接口 https://www.mulaen.com/



TGGPT GPT3.5 登录很卡 https://chat.tgbot.co/chat



New Chat GPT3.5 需API https://fastgpt.app/



开发交流 GPT3.5 免登录 https://chat.yqcloud.top



Ai117 GPT3.5 免登录 https://ai117.com/



周报通 GPT3.5 写周报专用 https://zhoubaotong.com/zh

Fake ChatGPT 未知 免登录 https://gpt.sheepig.top/chat



AI EDU GPT3.5 需API https://chat.forchange.cn/



中文公益版   免登录 https://gpt.tool00.com/



免费ChatGPT（论坛支持） GPT3 免登录 https://openaizh.com/chatgpt.html

AI Chat Bot GPT3 免登录，不稳定 https://chat.gptocean.com/

Hi icu GPT3 部分付费 https://hi.icu/

Aicodehelper GPT3 免登录 https://aicodehelper.com/

ChatGPT Robot 其他 其他 https://ai.zecoba.cn/

Ai帮个忙 其他 工具箱 https://ai-toolbox.codefuture.top/

GPTZero 内容检测 内容检测 https://gptzero.me/

ChatGPT中文版 GPT3.5 免登录 https://chat35.com/chat

import datetime as dt

import tkinter as tk

# Linux 护眼程序

sec = 60 # 休息时间 秒



root = tk.Tk()

root.config(bg='black')

root.wm_attributes('-topmost',1)

root.wm_attributes('-fullscreen',1)

L = tk.Label(root,font=('Consolas', 50), bg='black')

L.place(relx=0.5,rely=0.5,anchor=tk.CENTER)



# 改变的内容

msg = "{}\n 站起来 {} \n 动一动 {}\n{}"

now = dt.datetime.now()

aa = {0:'↑',1:'→',2:'↓',3:'←'}

bb = {0:'~~_↑_~~',1:'~_↑ ↑_~'}





for i in range(sec):

    t = msg.format(sec-i,aa[i%4],bb[i%2],(now+dt.timedelta(seconds=i)).ctime())

    c = 'Black' # 颜色可以搞随机换

    root.after(i*1000,L.config,{'text':t,'fg':c})

    root.after(sec*1000,root.destroy)



root.mainloop()

def initialize(context):

    # 初始化策略

    g.security = "600570.SS"

    set_universe(g.security)



def handle_data(context, data):

    stock=get_Ashares()

    log.info(stock)

    obj_list = get_trade_detail_data(ACCOUNT,'stock','position')

    for obj in obj_list:

        print(obj.m_strInstrumentID,obj.m_strInstrumentName,'----')

        # 查看有哪些属性字段

        print('='*10)

        for item in dir(obj):

            if not item.startswith('__'):

                print(item)

                

        print('='*10)

m_bIsToday

m_dAvgOpenPrice

m_dCloseAmount

m_dCloseProfit

m_dFloatProfit

m_dInstrumentValue

m_dLastPrice

m_dLastSettlementPrice

m_dMargin

m_dMarketValue

m_dOpenCost

m_dOpenPrice

m_dPositionCost

m_dPositionProfit

m_dProfitRate

m_dRealUsedMargin

m_dRedemptionVolume

m_dReferenceRate

m_dRoyalty

m_dSettlementPrice

m_dSingleCost

m_dStaticHoldMargin

m_dStockLastPrice

m_dStructFundVol

m_dTotalCost

m_eFutureTradeType

m_eSideFlag

m_nCanUseVolume

m_nCidIncrease

m_nCidIsDelist

m_nCidRateOfCurrentLine

m_nCidRateOfTotalValue

m_nCloseVolume

m_nCoveredVolume

m_nDirection

m_nEnableExerciseVolume

m_nFrozenVolume

m_nHedgeFlag

m_nLegId

m_nOnRoadVolume

m_nOptCombUsedVolume

m_nPREnableVolume

m_nVolume

m_nYesterdayVolume

m_strAccountID

m_strAccountKey

m_strComTradeID

m_strExchangeID

m_strExchangeName

m_strExpireDate

m_strInstrumentID

m_strInstrumentName

m_strOpenDate

m_strProductID

m_strProductName

m_strStockHolder

m_strTradeID

m_strTradingDay

m_xtTag

def init(ContextInfo):

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

    ContextInfo.start = '2023-02-20 10:00:00'

    ContextInfo.end = '2023-02-23 10:00:00'

    if not ContextInfo.is_last_bar():

        return

# encoding:gbk

import logging

import pandas as pd

from datetime import datetime, timedelta, time

from decimal import InvalidOperation

from decimal import Decimal as D

from READFILE import read_file



logging.basicConfig(level=logging.INFO)

# 挂单失败后的等待时长，以秒计

TIMEOUT_ON_FAIL_SEC = 30

# 规避 account_callback 的 Racing Condition

RUN_TIME_DELAY = 10



# global FILEPATH, DIR, PRICE, VOL, START_TIME, account

SH_pattern = r'^[1-9]\d{5}\.(sh|SH)$'

SZ_pattern = r'^(?!39)\d{6}\.(sz|SZ)$'

SH_prefix = ['5', '6', '9', '11']

SZ_prefix = ['0', '2', '30', '12', '159']

COLNAMES = ['direction', 'vol', 'price', 'start_time']





def init(ContextInfo):

    ContextInfo.accID = account

    ContextInfo.set_account(ContextInfo.accID)



    ContextInfo.can_order = False

    ContextInfo.all_order_done = False



    if not load_file_order(ContextInfo):

        load_sys_order(ContextInfo)



    # load_file_order(ContextInfo)

    ContextInfo.run_time("place_order", "{0}nSecond".format(TIMEOUT_ON_FAIL_SEC),

                         (datetime.now() + timedelta(seconds=RUN_TIME_DELAY)).strftime('%Y-%m-%d %H:%M:%S'), 'SH')





def account_callback(ContextInfo, accountInfo):

    if not ContextInfo.can_order:

        ContextInfo.can_order = True





def handlebar(ContextInfo):

    return





def load_file_order(ContextInfo):

    def _price_vol_filtering(row):

        if not isinstance(row.start_time, time):

            logging.warning('读取{0}指令时间失败: {1}'.format(row.name, row.start_time))

            return None

        if row.direction not in ['买', '卖']:

            logging.warning('读取{0}买卖方向失败: {1}'.format(row.name, row.direction))

            return None

        try:

            # parse start_time

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

            curr_start_time = datetime.strptime(curr_start_time, '%Y-%m-%d %H:%M:%S')

            # parse direction

            curr_direction = 23 if row.direction == '买' else 24

            # parse price and vol

            price = D(row.price)

            vol = int(row.vol)

            return pd.Series([curr_direction, vol, price, curr_start_time])

        except InvalidOperation:

            logging.warning("读取 {0} 指令价格失败: {1}".format(row.name, row.price))

            return None

        except ValueError:

            logging.warning('读取 {0} 下单总量失败: {1}'.format(row.name, row.vol))

            return None



    def _name_parser(asset_name):

        # 目前默认用户输入.SH 或.SZ时标的名称正确

        if '.SH' in asset_name or '.SZ' in asset_name:

            # todo: SH/SZ_pattern regex check here?

            return asset_name

        else:

            raise ValueError('{0} 标的代码不合法'.format(asset_name))



    try:

        tmp_df = read_file(FILEPATH, names=COLNAMES, index_col=0)

    except:

        logging.warning('读取挂单配置文件失败或挂单配置文件为空，尝试交易读取配置面板参数')

        return None

    if tmp_df.empty:

        logging.warning('读取挂单配置文件失败或挂单配置文件为空，尝试交易读取配置面板参数')

        return None



    tmp_df.index = tmp_df.index.to_series().astype(str)

    tmp_df.index = tmp_df.index.str.strip()

    tmp_df.index = tmp_df.index.str.upper()

    tmp_df.index = tmp_df.index.to_series().apply(_name_parser).dropna()

    tmp_df = tmp_df.apply(_price_vol_filtering, axis=1, broadcast=True).dropna()

    if tmp_df.empty:

        logging.warning('读取挂单配置文件失败或挂单配置文件为空，尝试交易读取配置面板参数')

        return False



    tmp_df.set_axis(COLNAMES, axis='columns', inplace=True)

    # 挂单成功Flag

    tmp_df['finished'] = [False] * tmp_df.shape[0]

    ContextInfo.order_df = tmp_df

    ContextInfo.set_universe(ContextInfo.order_df.index.tolist())

    return True





def load_sys_order(ContextInfo):

    try:

        asset_name = ContextInfo.stockcode + '.' + ContextInfo.market

        ContextInfo.set_universe([asset_name])

        direction = 23 if DIR == '买入' else 24

        start_time = datetime.strptime(datetime.now().strftime('%Y%m%d') + str(START_TIME), '%Y%m%d%H%M%S')

        price = D(PRICE)

        vol = int(VOL)

    except BaseException:

        raise ValueError("读取策略面板交易配置失败。请尝试修正挂单配置文件或者策略面板参数。")



    price = float(price)

    ContextInfo.order_df = pd.DataFrame(data=[direction, vol, price, start_time], index=COLNAMES,

                                        columns=[asset_name]).T

    ContextInfo.order_df['finished'] = False

    return





def place_order(ContextInfo):

    if not ContextInfo.can_order or ContextInfo.all_order_done:

        return

    for curr_asset in ContextInfo.get_universe():

        if not ContextInfo.order_df.loc[curr_asset].finished \

                and datetime.now() > ContextInfo.order_df.loc[curr_asset].start_time:

            curr_order = ContextInfo.order_df.loc[curr_asset]

            direction = int(curr_order.direction)

            txt_direction = '买入' if direction == 23 else '卖出'

            price = float(D(curr_order.price))

            vol = int(curr_order.vol)

            order_remark = '隔日文件挂单: 以 {0} {1} {2}'.format(price, txt_direction, curr_asset)

            passorder(direction, 1101, ContextInfo.accID, curr_asset, 11, price, vol, order_remark, 1, order_remark,

                      ContextInfo)

            ContextInfo.order_df.loc[curr_asset, 'finished'] = True



    ContextInfo.all_order_done = all(ContextInfo.order_df['finished'].tolist())





def order_callback(ContextInfo, orderInfo):

    curr_asset = orderInfo.m_strInstrumentID + '.' + orderInfo.m_strExchangeID

    curr_remark = orderInfo.m_strRemark

    curr_status = orderInfo.m_nOrderStatus

    if '隔日文件挂单' in curr_remark and curr_status == 57:

        ContextInfo.order_df.loc[curr_asset, 'finished'] = False

        ContextInfo.all_order_done = False

        logging.error('{0} 隔日文件挂单：报单废单 (柜台返回失败)，原因：{1} 尝试重报'.format(curr_asset, orderInfo.m_strCancelInfo))

    elif '隔日文件挂单' in curr_remark and curr_status == 50:

        logging.info('{0} 隔日文件挂单：报单成功'.format(curr_asset))

    return





def orderError_callback(ContextInfo, orderArgs, errMsg):

    curr_asset = orderArgs.orderCode

    if '隔日文件挂单' in orderArgs.strategyName:

        ContextInfo.order_df.loc[curr_asset, 'finished'] = False

        ContextInfo.all_order_done = False

        logging.error('{0} 隔日文件挂单：账号下单异常 (COS/iQuant校验失败), 错误消息：{1} 尝试重报'.format(curr_asset, errMsg))

        return

综合交易下单 passorder()

用法： passorder(opType, orderType, accountid, orderCode, prType, modelprice, volume[, strategyName, quickTrade, userOrderId], ContextInfo)

期货六键：



0：开多



1：平昨多



2：平今多



3：开空



4：平昨空



5：平今空



期货四键：



6：平多,优先平今



7：平多,优先平昨



8：平空,优先平今



9：平空,优先平昨



期货两键：



10：卖出,如有多仓,优先平仓,优先平今,如有余量,再开空



11：卖出,如有多仓,优先平仓,优先平昨,如有余量,再开空



12：买入,如有空仓,优先平仓,优先平今,如有余量,再开多



13：买入,如有空仓,优先平仓,优先平昨,如有余量,再开多



14：买入,不优先平仓



15：卖出,不优先平仓



股票买卖：



23：股票买入，或沪港通、深港通股票买入



24：股票卖出，或沪港通、深港通股票卖出



融资融券：



27：融资买入



28：融券卖出



29：买券还券



30：直接还券



31：卖券还款



32：直接还款



33：信用账号股票买入



34：信用账号股票卖出



组合交易：



25：组合买入，或沪港通、深港通的组合买入



26：组合卖出，或沪港通、深港通的组合卖出



27：融资买入



28：融券卖出



29：买券还券



31：卖券还款



33：信用账号股票买入



34：信用账号股票卖出



40：期货组合开多



43：期货组合开空



46：期货组合平多,优先平今



47：期货组合平多,优先平昨



48：期货组合平空,优先平今



49：期货组合平空,优先平昨



期权交易：



50：买入开仓



51：卖出平仓



52：卖出开仓



53：买入平仓



54：备兑开仓



55：备兑平仓



56：认购行权



57：认沽行权



58：证券锁定



59：证券解锁

passorder(23,1101,account,s,11,14.00,100,2,ContextInfo)

1101：单股、单账号、普通、股/手方式下单



1102：单股、单账号、普通、金额（元）方式下单（只支持股票）



1113：单股、单账号、总资产、比例 [0 ~ 1] 方式下单



1123：单股、单账号、可用、比例[0 ~ 1]方式下单



1201：单股、账号组（无权重）、普通、股/手方式下单



1202：单股、账号组（无权重）、普通、金额（元）方式下单（只支持股票）



1213：单股、账号组（无权重）、总资产、比例 [0 ~ 1] 方式下单



1223：单股、账号组（无权重）、可用、比例 [0 ~ 1] 方式下单



2101：组合、单账号、普通、按组合股票数量（篮子中股票设定的数量）方式下单 > 对应 volume 的单位为篮子的份



2102：组合、单账号、普通、按组合股票权重（篮子中股票设定的权重）方式下单 > 对应 volume 的单位为元



2103：组合、单账号、普通、按账号可用方式下单 > （底层篮子股票怎么分配？答：按可用资金比例后按篮子中股票权重分配，如用户没填权重则按相等权重分配）只对股票篮子支持



2201：组合、账号组（无权重）、普通、按组合股票数量方式下单



2202：组合、账号组（无权重）、普通、按组合股票权重方式下单

-1：无效（实际下单时,需要用交易面板交易函数那设定的选价类型）



0：卖5价



1：卖4价



2：卖3价



3：卖2价



4：卖1价



5：最新价



6：买1价



7：买2价（组合不支持）



8：买3价（组合不支持）



9：买4价（组合不支持）



10：买5价（组合不支持）



11：（指定价）模型价（只对单股情况支持,对组合交易不支持）



12：涨跌停价



13：挂单价



14：对手价



27：市价即成剩撤(仅对股票期权申报有效)



28：市价即全成否则撤(仅对股票期权申报有效)



29：市价剩转限价(仅对股票期权申报有效)



42：最优五档即时成交剩余撤销申报(仅对上交所申报有效)



43：最优五档即时成交剩转限价申报(仅对上交所申报有效)



44：对手方最优价格委托(仅对深交所申报有效)



45：本方最优价格委托(仅对深交所申报有效)



46：即时成交剩余撤销委托(仅对深交所申报有效)



47：最优五档即时成交剩余撤销委托(仅对深交所申报有效)



48：全额成交或撤销委托(仅对深交所申报有效)



49：科创板盘后定价

passorder(

ContextInfo.TYPE_STOCK,



ContextInfo.TYPE_BUY,

100,

ContextInfo.LIMIT_PRICE,

ContextInfo)

volume，下单数量（股 / 手 / 元 / %）



passorder(opType, orderType, accountID, orderCode, prType, price, volume, ContextInfo)



根据 orderType 值最后一位确定 volume 的单位：



单股下单时：



1：股 / 手



2：金额（元）



3：比例（%）

ChatGPT共享账号

账号1：vickye89@hotmail.com

密码：LeZ25X5dwL

账号2：eugeniev552@hotmail.com

密码2：4w95MnvIvc

账号3：ayakonewuyo@hotmail.com

密码3：q8UCd2lST4

账号4：ludmillasteb9@hotmail.com

密码4：7sb54Oii8I

账号5：chr89kuchto@hotmail.com

密码5：Cea7IQj5ud

账号6：emil03mk@hotmail.com

密码6：ENC82hip2A

账号7：lydiavn9ktutoky@hotmail.com

密码7：6351VsZz25

账号8：tulagj3@hotmail.com

密码8：Wx99eCqer7

账号9：prue56zjehle@hotmail.com

密码9：8398k84X85

账号10：vernitagq2@hotmail.com

密码10：geFfr4H0x9

账号11：kirstiealtqw@hotmail.com

密码11：1FBbV8OJg9

账号12：ralphnamer32d@hotmail.com

密码12：F85T86YtbL

账号13：celinabullievmu@hotmail.com

密码13：OqTz0lj525

账号14：chanafdidelaet@hotmail.com

密码14：6x3CM4pPYY

账号15：alita07pbogdon@hotmail.com

密码15：Umppl1ylc0

账号16：averilltxgt@hotmail.com

密码16：94cymN2p42

账号17：mobyfotohy7@hotmail.com

密码17：c8iJi0Fd

账号18：muficylequ9@hotmail.com

密码18：5p0KWJf1D

账号19：naehahogujo0@hotmail.com

密码19：xgH5o3jKV

账号20：naejexelibu@hotmail.com

密码20：fZg44fVeh

账号21：naezhaeshequsito@outlook.com

密码21：PtRbh31IF

账号22：neladeroka@hotmail.com

密码22：McTk3Qrz

账号23：pyvohywaeli@outlook.com

密码23：Ehk9d5QFz4

账号24：qadakidone@hotmail.com

密码24：I836s6941q

账号25：qaraesisheby9@hotmail.com

密码25：UQkJim80c

账号26：qaxiberasipy@outlook.com

密码26：XVYluIYy2P

账号27：qeluzhaelagy4@hotmail.com

密码27：8qZEl20fR

账号28：qobiluno7@hotmail.com

密码28：4KiM2C0q9

账号29：qupipaeshe1@outlook.com

密码29：4j9NSpGHEZ

账号30：qyshymisifi0@hotmail.com

密码30：Sfp9D0UNK4

账号31：raehotushawo@hotmail.com

密码31：2d0H8o9L

from flask import Flask

app = Flask(__name__)



@app.route('/')

def hello_world():

    return 'Hello, World!'

Starting February 1, 2022, we will begin charging $0.60 per custom domain per month beyond the first 25 custom domains for a web service or static site. The first 25 custom domains for web services and static sites will continue to be free.

#encoding:gbk



def init(ContextInfo):

    print('hello world')

    

def handlebar(ContextInfo):

    #计算当前主图的cci

    print("handle bar")

（3）Handlebar



handlebar 是整个 Python 模型中的核心执行函数。当模型从数据层获取到运行所需要的数据之后，会对数据集上的每一根 bar，调用一次 handlebar 函数，处理当前这根 bar 上的数据。也就是说，用户模型的核心逻辑都是写在该函数中的，如获取数据，设置下单条件等。在 handlebar 中处理完数据后，用户可以通过 paint 方法将需要绘图输出的结果返回给界面。界面会将输出结果如实的展示出来。

（4）ContextInfo



ContextInfo 是整个 Python 框架中的一个核心对象。它包含了各种与 Python 底层框架交互的 API 方法，也是一个全局的上下文环境，可以在 init 以及 handlebar 这两个函数中自由地传递用户创建的各种自定义数据。

def init(ContextInfo):

    pass

    

def handlebar(ContextInfo):

    pass

# encoding:gbk

import logging

from datetime import datetime, timedelta

from decimal import Decimal as D

from decimal import InvalidOperation



logging.basicConfig(level=logging.INFO)



# 挂单失败后的等待时长，以秒计

TIMEOUT_ON_FAIL_SEC = 30

# 等待account_callback的时长

# RUN_TIME_DELAY = 30



# how is this not defined in package??

MORNING_START = datetime.strptime(datetime.now().strftime('%Y%m%d') + '093000', '%Y%m%d%H%M%S')

MORNING_END = datetime.strptime(datetime.now().strftime('%Y%m%d') + '113000', '%Y%m%d%H%M%S')

NOON_START = datetime.strptime(datetime.now().strftime('%Y%m%d') + '130000', '%Y%m%d%H%M%S')

NOON_END = datetime.strptime(datetime.now().strftime('%Y%m%d') + '153000', '%Y%m%d%H%M%S')



# for SH only

TRANS_COST_1D = D('5e-6')

TRANS_COST_LONG = D('1.5e-7')

TRANS_COST_MAX = 100



# ORDER LIMITS

SH_UPPER = 1e7

SH_LOWER = 1e5

SZ_UPPER = 1e8

SZ_LOWER = 1e3



# ASSET NAME DICT

SH_REV_REPO = {'上交所1天': '204001.SH', '上交所2天': '204002.SH', '上交所3天': '204003.SH',

               '上交所4天': '204004.SH', '上交所7天': '204007.SH', '上交所14天': '204014.SH',

               '上交所28天': '204028.SH', '上交所91天': '204091.SH', '上交所182天': '204182.SH',

               }



SZ_REV_REPO = {'深交所3天': '131800.SZ', '深交所7天': '131801.SZ', '深交所14天': '131802.SZ',

               '深交所28天': '131803.SZ', '深交所91天': '131805.SZ', '深交所182天': '131806.SZ',

               '深交所4天': '131809.SZ', '深交所1天': '131810.SZ', '深交所2天': '131811.SZ',

               }





def init(ContextInfo):

    ContextInfo.accID = account

    ContextInfo.set_account(ContextInfo.accID)

    ContextInfo.use_all_cap = False if ALL_CAP == '否' else True



    # global trading control, set to False if detected error on user's side

    # stop() does not halt strat

    ContextInfo.order_control = False



    if not ContextInfo.use_all_cap:

        try:

            ContextInfo.dollar_vol = float(D(DOLLAR_VOL))

        except InvalidOperation:

            ContextInfo.order_control = True

            raise ValueError('读取资金量失败')

    else:

        if DOLLAR_VOL != '':

            logging.warning('已设定使用全部账户资金，忽略所设置资金量')



    try:

        ContextInfo.start_time = datetime.strptime(datetime.now().strftime('%Y%m%d') + str(START_TIME), '%Y%m%d%H%M%S')

        ContextInfo.asset_name = SH_REV_REPO[ASSET_NAME]

    except KeyError:

        ContextInfo.asset_name = SZ_REV_REPO[ASSET_NAME]

    except ValueError as error:

        if 'unconverted data remains' in str(error):

            ContextInfo.order_control = True

            raise ValueError('读取挂单时间失败')



    if not (MORNING_END > ContextInfo.start_time >= MORNING_START) \

            and not (NOON_END > ContextInfo.start_time >= NOON_START):

        ContextInfo.order_control = True

        raise ValueError('挂单时间不在可交易时间内')



    ContextInfo.can_order = False

    ContextInfo.order_done = False



    if not ContextInfo.order_control:

        ContextInfo.run_time("place_order", "{0}nSecond".format(TIMEOUT_ON_FAIL_SEC),

                             ContextInfo.start_time.strftime('%Y-%m-%d %H:%M:%S'), 'SH')





def account_callback(ContextInfo, accountInfo):

    if not ContextInfo.can_order:

        ContextInfo.can_order = True

        if ContextInfo.use_all_cap:

            ContextInfo.dollar_vol = accountInfo.m_dAvailable

        else:

            if ContextInfo.dollar_vol > accountInfo.m_dAvailable:

                ContextInfo.order_control = True

                raise ValueError('下单额度大于账户可用资金')



        # check if order satisfies lower limit for each exchange

        if ('SH' in ContextInfo.asset_name and ContextInfo.dollar_vol < SH_LOWER) \

                or ('SZ' in ContextInfo.asset_name and ContextInfo.dollar_vol < SZ_LOWER):

            ContextInfo.order_control = True

            raise ValueError('下单额度低于交易所最低限额')



        # checks dollar_vol and rounds the total amount

        if 'SH' in ContextInfo.asset_name and ContextInfo.dollar_vol % SH_LOWER != 0:

            ContextInfo.dollar_vol = (ContextInfo.dollar_vol // SH_LOWER) * SH_LOWER

            logging.warning('下单额度已规整为：{0}'.format(ContextInfo.dollar_vol))

        elif 'SZ' in ContextInfo.asset_name and ContextInfo.dollar_vol % SZ_LOWER != 0:

            ContextInfo.dollar_vol = (ContextInfo.dollar_vol // SZ_LOWER) * SZ_LOWER

            logging.warning('下单额度已规整为：{0}'.format(ContextInfo.dollar_vol))



        '''

        if 'SH' in ContextInfo.asset_name:

            num_batch_order = int(ContextInfo.dollar_vol // SH_UPPER)

            remain_order = ContextInfo.dollar_vol - num_batch_order * SH_UPPER

            if ContextInfo.asset_name == '204001.SH':

                transaction_cost = TRANS_COST_MAX * num_batch_order + remain_order * TRANS_COST_1D

            else:

                transaction_cost = TRANS_COST_MAX * num_batch_order + remain_order * TRANS_COST_LONG

            if transaction_cost + ContextInfo.dollar_vol > accountInfo.m_dAvailable:

                ContextInfo.order_control = True

                raise ValueError('可用资金不足以垫付交易金额与手续费')

       '''



        ContextInfo.remain_vol = ContextInfo.dollar_vol





def handlebar(ContextInfo):

    return





def place_order(ContextInfo):

    if not ContextInfo.can_order or ContextInfo.order_control:

        return



    if not ContextInfo.order_done:

        if 'SH' in ContextInfo.asset_name:

            num_batch_order = int(ContextInfo.remain_vol // SH_UPPER)

            remain_order = ContextInfo.remain_vol - num_batch_order * SH_UPPER

            for _ in range(num_batch_order):

                order_remark = '国债逆回购：尝试报单{0}元 {1}'.format(SH_UPPER, ContextInfo.asset_name)

                passorder(24, 1102, ContextInfo.accID, ContextInfo.asset_name, 5, -1, SH_UPPER, order_remark, 1,

                          order_remark, ContextInfo)

        else:

            num_batch_order = int(ContextInfo.remain_vol // SZ_UPPER)

            remain_order = ContextInfo.remain_vol - num_batch_order * SZ_UPPER

            for _ in range(num_batch_order):

                order_remark = '国债逆回购：尝试报单{0}元 {1}'.format(SZ_UPPER, ContextInfo.asset_name)

                passorder(24, 1102, ContextInfo.accID, ContextInfo.asset_name, 5, -1, SZ_UPPER, order_remark, 1,

                          order_remark, ContextInfo)



        order_remark = '国债逆回购：尝试报单{0}元 {1}'.format(remain_order, ContextInfo.asset_name)

        passorder(24, 1102, ContextInfo.accID, ContextInfo.asset_name, 5, -1, remain_order, order_remark, 1,

                  order_remark, ContextInfo)



        ContextInfo.remain_vol = 0

        ContextInfo.order_done = True





def order_callback(ContextInfo, orderInfo):

    curr_remark = orderInfo.m_strRemark

    curr_status = orderInfo.m_nOrderStatus



    if '国债逆回购' in curr_remark and ContextInfo.asset_name in curr_remark and curr_status == 57:

        ContextInfo.order_done = False

        # up the leftover dollar vol by failed amount

        # logging.info('reported trade amount:{0}, reported_trade_volume:{1}'.format(orderInfo.m_dTradeAmount, orderInfo.m_nVolumeTotal))

        # 单张100元

        ContextInfo.remain_vol += orderInfo.m_nVolumeTotal * 100

        if '交易时间不合法' in orderInfo.m_strCancelInfo:

            ContextInfo.order_control = True

            raise ValueError('国债逆回购：未能在交易时间内完成下单，停止报单。余量{0}元未报'.format(ContextInfo.remain_vol))

        logging.warning('国债逆回购：报单废单，原因：\"{0}\"，尝试重报'.format(orderInfo.m_strCancelInfo))

    elif '国债逆回购' in curr_remark and ContextInfo.asset_name in curr_remark and curr_status == 50:

        logging.info('国债逆回购：报单{0}元成功'.format(orderInfo.m_nVolumeTotal * 100))

    return









待续，不定期更新

在模型编辑器中，有“回测”和“运行”两个按钮，分别代表两种模式，它们之间的区别如下：

（1）回测模式指策略以历史行情为依据，以回测参数中的开始时间、结束时间为回测时间区间进行运

算，投资者可观察该策略在历史行情所获得的年化收益率、夏普比率、最大回撤、信息比率等指标表

现。



（2）运行模式指策略根据实时行情信号进行运算，以主图行情开始时间到当前时间为运行区间，进行策

略的模拟运行，但不进行真实的委托。



注：如果需要向模拟/实盘柜台发送真实的委托，请将策略加入到“模型交易”中。

盘后运行可能会有抽风现象。



回测的时候日期问题，只能选副图，不知道为何

def initialize(context):

    g.security = ['IF1712.CCFX', 'CU1806.XSGE']

    set_universe(g.security)



def handle_data(context, data):

    #买入开仓

    buy_open('IF1712.CCFX', 1)



    #买入开仓(限定点数为52220)

    buy_open('CU1806.XSGE', 1, limit_price=52220)

def initialize(context):

    g.security = ['IF1712.CCFX', 'CU1806.XSGE']

    set_universe(g.security)



def handle_data(context, data):

    #卖出平仓

    sell_close('IF1712.CCFX', 1)

    #卖出平今仓(限定点数为52220)

    sell_close ('CU1806.XSGE', 1, limit_price=52220, close_today=True)

    #卖出平仓(限定点数为52220)

    sell_close ('CU1806.XSGE', 1, limit_price=52220)

get_instruments(contract)

返回

FutureParams对象，主要返回的字段为:

contract_code -- 合约代码，str类型；
contract_name -- 合约名称，str类型；
exchange -- 交易所：大商所、郑商所、上期所、中金所，str类型；
trade_unit -- 交易单位，int类型；
contract_multiplier -- 合约乘数，float类型；
delivery_date -- 交割日期，str类型；
listing_date -- 上市日期，str类型；
trade_code -- 交易代码，str类型；
margin_rate -- 保证金比例，float类型；

def initialize(context):

    g.security = ["CU2112.XSGE", "IF2112.CCFX"]

    set_universe(g.security)



def before_trading_start(context, data):

    # 获取股票池代码合约信息

    for security in g.security:

        info = get_instruments(security)

    log.info(info)



def handle_data(context, data):

    pass

使用场景

该函数在交易模块可用



接口说明

该接口用于获取当日分时成交行情数据。



注意事项：



1、沪深市场都有分时成交数据；



2、分时成交数据需开通level2行情才有数据推送，否则无数据返回；

返回

返回一个OrderedDict对象，包含每只代码的分时成交行情数据。(OrderedDict([(),()...]))



返回结果字段介绍：



time_stamp: 时间戳毫秒级(str:numpy.int64)；

hq_px: 价格(str:numpy.float64)；

hq_px64: 价格(str:numpy.int64)(行情暂不支持，返回均为0)；

business_amount: 成交数量(str:numpy.int64)；

business_balance: 成交金额(str:numpy.int64)；

business_count: 成交笔数(str:numpy.int64)；

business_direction: 成交方向（0：卖，1：买，2：平盘)(str:numpy.int64)；

amount: 持仓量(str:numpy.int64)(行情暂不支持，返回均为0)；

start_index: 分笔关联的逐笔开始序号(str:numpy.int64)(行情暂不支持，返回均为0)；

end_index: 分笔关联的逐笔结束序号(str:numpy.int64)(行情暂不支持，返回均为0)；

def initialize(context):

    g.security = '000001.SZ'

    set_universe(g.security)



def handle_data(context, data):

    #获取000001.SZ的分时成交数据

    direction_data = get_tick_direction(g.security)

    log.info(direction_data)

    #获取指定股票列表分时成交数据

    direction_data = get_tick_direction(['000002.SZ','000032.SZ'])

    log.info(direction_data)

    #获取成交量

    business_amount = direction_data['000002.SZ']['business_amount']

    log.info('分时成交的成交量为：%s' % business_amount)

def remove_st_stock(all_stock_list):

    st_dict = get_stock_status(all_stock_list, query_type='ST', query_date=None)

    st_list = []

    for k, v in st_dict.items():

        if v:

            st_list.append(k)

    return st_list



MARKET_DICT = {0: '科创板', 1: '创业板', }

IGNORE_MARKET = [0, 1]



def all_codes_in_market():

    all_stock_set = set(get_Ashares(date=None))

    for ignore_code in IGNORE_MARKET:

        market = MARKET_DICT.get(ignore_code)

        if market == '科创板':

            all_stock_set = all_stock_set - set(filter(lambda x: x.startswith('68'), all_stock_set))

        if market == '创业板':

            all_stock_set = all_stock_set - set(filter(lambda x: x.startswith('3'), all_stock_set))



    return all_stock_set





def create_target(context):

    all_stock_set = all_codes_in_market()

    st_list = remove_st_stock(list(all_stock_set))

    all_stock_set = all_stock_set - set(st_list)

    return all_stock_set

MARKET_DICT = {0: '科创板', 1: '创业板', }

IGNORE_MARKET = [0, 1]



def create_target(context):



    all_stock_set = set(get_Ashares(date=None))

    for ignore_code in IGNORE_MARKET:

        market = MARKET_DICT.get(ignore_code)

        if market == '科创板':

            all_stock_set = all_stock_set - set(filter(lambda x:x.startswith('68'),all_stock_set))

        if market == '创业板':

            all_stock_set = all_stock_set - set(filter(lambda x:x.startswith('3'),all_stock_set))



    return all_stock_set