A mão a mão ensina-te a envelopar um documento de políticas Python de forma barata.

A mão a mão ensina-te a envelopar um documento de políticas Python de forma barata.

Este artigo fala de duas soluções, e a outra é mais simples (recomendada) no final do artigo.

Muitos desenvolvedores que usam o Python para escrever políticas querem manter seus arquivos de código localmente, preocupados com a segurança das políticas.FMZ APIO documento propõe uma solução:

Segurança estratégica Desenvolver estratégias em plataformas de negociação quantitativa de inventores, visíveis apenas para os titulares de contas de quantificação de inventores. E, em plataformas de negociação quantitativa de inventores, é possível realizar a localização completa do código da política, como envelopar a política em um pacote Python e carregá-la no código da política, o que permite a localização da política.https://www.fmz.com/api#%E7%AD%96%E7%95%A5%E5%AE%89%E5%85%A8%E6%80%A7

A preocupação é desnecessária, mas uma solução como essa é um exemplo completo de como isso pode ser feito.

Envolver uma estratégia

Nós encontramos uma estratégia simples de Python para fazer uma demonstração, usando o clássicoDual ThrustA estratégia, o endereço da estratégia:https://www.fmz.com/strategy/21856Nós nos esforçamos para não alterar qualquer código da parte da política, para envelopar a política em um documento que possa ser chamado pelo código da política na plataforma FMZ e que seja totalmente consistente com o resultado da execução e a execução direta da política. O maior problema com o envelopamento é que os objetos globais, funções globais, valores constantes que são chamados pelo código da política na plataforma FMZ não são acessíveis no nosso documento embalado, então temos que encontrar uma maneira de passar esses objetos, funções, variáveis e constantes para o documento embalado.

• ReproduçãoPython versão Dual Thrust OKCoin futurosO código da estratégia é colado em um arquivo Python local chamado testA.

Passe testA no arquivo aberto no editor local.

• Adicionou um pouco de código para manter a parte original do código da política de copiar e colar

  # 函数、对象
  exchanges = None
  exchange = None
  Log = None
  Sleep = None
  TA = None
  Chart = None
  LogProfitReset = None
  LogStatus = None
  _N = None
  _C = None 
  LogProfit = None  
  

  # 策略参数
  ContractTypeIdx = None
  MarginLevelIdx = None
  NPeriod = None
  Ks = None
  Kx = None
  AmountOP = None
  Interval = None
  LoopInterval = None
  PeriodShow = None  

  # 常量
  ORDER_STATE_PENDING = 0
  ORDER_STATE_CLOSED = 1
  ORDER_STATE_CANCELED = 2
  ORDER_STATE_UNKNOWN = 3
  ORDER_TYPE_BUY = 0 
  ORDER_TYPE_SELL = 1
  PD_LONG = 0
  PD_SHORT = 1  
  

  def SetExchanges(es):
      global exchanges, exchange
      exchanges = es
      exchange = es[0]  

  def SetFunc(pLog, pSleep, pTA, pChart, pLogStatus, pLogProfitReset, p_N, p_C, pLogProfit):
      global Log, Sleep, TA, Chart, LogStatus, LogProfitReset, _N, _C, LogProfit
      Log = pLog
      Sleep = pSleep
      TA = pTA
      Chart = pChart
      LogStatus = pLogStatus
      LogProfitReset = pLogProfitReset
      _N = p_N
      _C = p_C
      LogProfit = pLogProfit  

  def SetParams(pContractTypeIdx, pMarginLevelIdx, pNPeriod, pKs, pKx, pAmountOP, pInterval, pLoopInterval, pPeriodShow):
      global ContractTypeIdx, MarginLevelIdx, NPeriod, Ks, Kx, AmountOP, Interval, LoopInterval, PeriodShow
      ContractTypeIdx = pContractTypeIdx
      MarginLevelIdx = pMarginLevelIdx
      NPeriod = pNPeriod
      Ks = pKs
      Kx = pKx
      AmountOP = pAmountOP
      Interval = pInterval
      LoopInterval = pLoopInterval
      PeriodShow = pPeriodShow

A função principal do código acima é declarar as funções globais usadas no documento atual; e reservar a interface para importar essas funções.SetExchanges，SetParams，SetFuncA estratégia na plataforma FMZ é chamar essas funções e passar algumas das funções usadas, objetos, etc.

Estratégias de inicialização na plataforma FMZ

A estratégia de inicialização é simples:

A única coisa que você precisa saber é que o código escrito na plataforma FMZ é apenas algumas linhas, e é importante notar que o parâmetro para esta política de inicialização é para envelopar a política que você está usando.Python versão Dual Thrust OKCoin futurosAssim, você pode copiar diretamente a estratégia "Python versão Dual Thrust OKCoin Futures" e limpar o código da estratégia e colar.

import sys
# 这里我写的是自己放置testA文件的路径，具体我替换为xxx了，简单说就是设置自己的testA文件路径就可以了
sys.path.append("/Users/xxx/Desktop/pythonPlayground/")
import testA

def main():
    # 传递交易所对象
    testA.SetExchanges(exchanges)
    # 传递全局函数 SetFunc(pLog, pSleep, pTA, pChart, pLogStatus, pLogProfitReset, p_N, p_C, pLogProfit)
    testA.SetFunc(Log, Sleep, TA, Chart, LogStatus, LogProfitReset, _N, _C, LogProfit)
    # 传递策略参数 SetParams(pContractTypeIdx, pMarginLevelIdx, pNPeriod, pKs, pKx, pAmountOP, pInterval, pLoopInterval, pPeriodShow)
    testA.SetParams(ContractTypeIdx, MarginLevelIdx, NPeriod, Ks, Kx, AmountOP, Interval, LoopInterval, PeriodShow)
    # 执行封装的testA文件中的策略主函数
    testA.main()

Assim, podemos envolver o sujeito lógico da política no arquivo testA e colocá-lo localmente no dispositivo onde o administrador está, e na plataforma FMZ, basta salvar uma política de inicialização para que o robô que criou essa política de inicialização possa carregar diretamente nosso arquivo local e executá-lo localmente no administrador.

Contraste de retestes

• Localização de testA

• A política original, repassada no servidor público

Outra maneira mais simples.

O arquivo pode ser carregado diretamente para a execução. Desta vez, preparamos um testB que coloca o código da estratégia "Python Dual Thrust OKCoin Futures".

import time
class Error_noSupport(BaseException):
    def __init__(self):
        Log("只支持OKCoin期货！#FF0000")

class Error_AtBeginHasPosition(BaseException):
    def __init__(self):
        Log("启动时有期货持仓! #FF0000")

ChartCfg = {
    '__isStock': True,
    'title': {
        'text': 'Dual Thrust 上下轨图'
    },
    'yAxis': {

...

A estratégia é muito longa e é omitida e o código da estratégia não precisa ser alterado. Em seguida, prepare o "Python Dual Thrust OKCoin Futures", que é a nossa estratégia na plataforma FMZ, criar um robô, carregar diretamente o testB e executá-lo diretamente. Note que o "Python Dual Thrust OKCoin Futures" deve ter a mesma configuração de parâmetros de estratégia do original.

if __name__ == '__main__':
    Log("run...")
    try:
        # 文件路径做了处理，可以写入自己testB文件放置的实际路径
        f = open("/Users/xxx/Desktop/pythonPlayground/testB.py", "r")
        code = f.read()
        exec(code)
    except Exception as e:
        Log(e)

Execute o teste de retorno:

Os resultados dos testes de repetição concordaram com os testes acima.

O segundo método é, obviamente, mais simples e recomendado, se há um melhor método, bem-vindo ao texto.