Plataforma

O stratsphera disponibiliza uma plataforma de algotrading em python baseada em eventos. A plataforma pode ser acessada através do hub de algoritmos na aba de estratégias do site do stratsphera.


Considerações gerais

Eventos

A plataforma é orientada a eventos. Seu funcionamento básico ocorre pela solicitação de eventos (como atualização de preços ou valores de variáveis macroeconômicas) para o módulo de dados e seu consequente recebimento pela estratégia pelos métodos dedicados. O desenvolvimento da estratégia deve ser primariamente voltado para definir a resposta desejada a cada evento.

Instrumentos na plataforma

A plataforma trabalha com base em objetos chamados instrumentos, que agrupam individualmente todas as informações e funcionalidades relativas a determinada entidade (como países, moedas, equities, variáveis macroeconômicas, etc.).

As informações e funções podem ser acessadas diretamente por meio dos instrumentos ou então pelas funções disponibilizadas nos módulos nativos da plataforma (data, order, time e position). As funções nativas são otimizadas, principalmente para requerimentos em múltiplos instrumentos. Elas aceitam referências aos instrumentos primariamente os próprios objetos, mas aceitam também seus símbolos (strings), fazendo a inferência quanto a que instrumento a estratégia está se referindo. A melhor prática é o uso dos instrumentos diretamente, dado que evita possíveis problemas com instrumentos de símbolo parecido (e.g.: negociação de pares idênticos de moedas em diferentes bolsas).

Diretrizes gerais

Os módulos e objetos nativos da plataforma obedecem as seguintes diretrizes gerais:

  • Geralmente, as respostas de funções da plataforma são emitidas em formato de dicionário com chave e valor sendo respectivamente o instrumento e o valor relativo a ele. A chave na resposta sempre manterá a referência utilizada na chamada da função, ou seja, se for usado o símbolo do instrumento na chamada da função, a resposta no dicionário terá como chave o símbolo em vez do instrumento;

  • Parâmetros que são aceitos em formato de listas podem ser também entregues como o parâmetro simples (no caso de um único elemento na lista). Nesse caso, a plataforma tentará simplificar o retorno da função extraindo-o do dicionário ou lista de resposta (caso haja apenas um elemento na resposta);

  • Objetos da plataforma podem ser printados (método print) para mostrar todos os seus atributos em conjunto com seus valores atuais.

  • A plataforma só se comunica com a estratégia através dos métodos nativos de recepção de eventos, e dos objetos nativos da plataforma (ver dorothy, instrumentos e settings). Qualquer variável configurada na estratégia não será percebida pela plataforma e portanto não surtirá qualquer efeito direto sobre a execução.


Dorothy

O módulo dorothy carrega todas as interfaces com a plataforma.

Os seguintes módulos podem ser importados dela:

  • data: aquisição de dados em geral;
  • time: consultas de horário e agendamento de funções;
  • order: envio, acompanhamento e cancelamento de ordens;
  • position: acompanhamento de posições e outras consultas a posses em geral;

A dorothy também conta com as seguinte funções:


custom_warning()

Descrição:
Registra um warning criado pela estratégia. Warnings repetidos serão desconsiderados.

Chamada:
custom_warning(warning)

  • warning: string.
    • Especifica o warning a ser emitido.

Exemplo:

1
2
3
4
5
6
7
8
from dorothy import StrategyBase, position, custom_warning

class Strategy(StrategyBase):
    ...

    def on_exit(self):
        if position.roc() < 0:
            custom_warning('result is below 0')

kill_strategy()

Descrição:
Bloqueia o recebimento de eventos pela estratégia, cancela todas as ordens ativas e fecha todas as posições existentes com ordens a mercado.

Chamada:
kill_strategy()

Exemplo:

1
2
3
4
5
6
7
8
from dorothy import StrategyBase, data, position, kill_strategy

class Strategy(StrategyBase):
    ...

    def on_day_close(self):
        if position.roc() < -0.5:
            kill_strategy()

Por fim, conta também com a classe StrategyBase que deve ser herdada pela classe principal da estratégia.

Para simplificar as importações, pode-se também usar from dorothy import * para disponibilizar todos os objetos da dorothy para a estratégia.

A dorothy só pode ser acessada pelo portal do stratsphera e não está disponível para uso externo.


Classe Strategy e eventos

A classe Strategy é a parte principal da estratégia, sendo utilizado para implementar o algoritmo. Ela deve sempre herdar da classe StrategyBase para seu correto funcionamento (StrategyBase pode ser importada da dorothy com o comando from dorothy import StrategyBase).

As estratégias funcionam com base em dados de mercado continuamente informados ao algoritmo. A chegada de uma nova informação é chamada de evento e pode ser classificada em diversos tipos, carregando dados de naturezas diferentes. Com exceção dos eventos de inicialização e de finalização da estratégia, os eventos ocorrem sob solitação da plataforma através do módulo data.

Na chegada de cada evento, a plataforma se comunicará com a estratégia chamando o método receptor nativo dedicado ao recebimento daquele tipo de evento. Esses métodos devem ser modificados para implementar a resposta desejada da estratégia a cada evento. Se não forem definidos, a estratégia irá ignorar a chegada do evento.

Os métodos receptores de eventos dispoveís são:

Eventos


on_init()

Descrição:
Evento chamado uma única vez antes do início da execução da estratégia. É usado principalmente para assinar os instrumentos a serem utilizados, inicializar variáveis da estratégia e configurar os parâmetros do backtest. As configurações somente surtirão efeito após o encerramento do método on_init.

Definição:
on_init(self, settings)

  • settings: Configurações do usuário, referentes a custos transacionais e de posição, execução de ordens, gestão de risco, entre outros.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    """
    Essa estratégia apenas solicita dados de preço de alguns papéis e, em seguida, configura alguns parâmetros da execução.
    Os eventos de atualização de preço serão recebidos no método on_bar_close, definido em breve.
    """

    def on_init(self, settings):
        # Lista de ativos a serem usados
        lista_ativos = ['PETR3', 'PETR4', 'VALE3']

        # Assinar ativos
        self.instrumentos = data.subscribe.price_bar(lista_ativos)

        # Configurações
        settings.execution.percent_of_volume = 30  # 30%
        settings.cost.commission.add(fee=10) # 10 bps (1 bps = 0.01%)
        settings.execution.slippage = 7  # 7 bps

on_day_open()

Descrição:
Evento a ser chamado no início de cada dia (abertura de bolsa). Casos de uso que podem conter esse evento:

  • Cálculos diários a serem usados durante o dia;
  • Iniciar funções de agendamento recorrentes ou não;
  • Atualizar variáveis diárias.

Definição:
on_day_open(self)

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):

        # Lista de ativos a serem usados
        self.lista_ativos = ['PETR3', 'PETR4', 'VALE3']

        # Assinar ativos
        data.subscribe.price_bar(self.lista_ativos)

        # Média de 15 dias
        self.media = {}
        self.contador_dias = 0

    def on_day_open(self):
        self.contador_dias = self.contador_dias + 1
        if self.contador_dias > 15:
            for instrument in self.lista_ativos:
                self.media[instrument] = data.get.hist.bar_close(instrument, length=15).mean()

on_bar_close()

Descrição:
Evento a ser chamado a cada fechamento de barra de preço para cada instrumento assinado.

Definição:
on_bar_close(self, bar)

  • bar: Barra de preços, contendo os campos abaixo.
    • ticker: Símbolo do ativo.
    • open: Preço de abertura do período da barra.
    • high: Maior preço durante o período da barra.
    • low: Menor preço durante o período da barra.
    • close: Preço de fechamento do período da barra.
    • vwap: Preço médio ponderado por volume durante o período da barra.
    • volume: Volume negociado durante o período da barra.
    • close_time: Horário de fechamento/formação da barra.
    • first_trade_time: Horário da primeira negociação na barra.
    • outlier: Classificação da plataforma quanto à validade da barra.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):
    def on_init(self, settings):
        self.ativo = data.subscribe.price_bar('ABEV3')

    def on_bar_close(self, bar):
        print(bar)  # mostrando todas as informações da barra no log
        if bar.close / bar.open > 1.1:  # Se a barra fechou com um preço 10% maior do que abriu, enviar uma ordem
            order.send.limit(
                instrument=self.ativo,
                side='BUY',
                size=10000,
                limit=bar.close * 0.99,
            )

on_order_status()

Descrição:
Evento chamado sempre que uma ordem é atualizada. Os seguintes estados (status) são possíveis:

  • REJECTED: A ordem não foi enviada para execução, pois violou algum critério de envio (e.g., não havia capital suficiente para sua execução, possuía tamanho nulo, tentou comprar um ativo que não havia sido assinado ou que ainda não tinha preço) e tornou-se inativa;
  • PENDING_SUBMIT: Estado da ordem anterior ao seu envio para execução ou rejeição;
  • SUBMITTED: Estado da ordem após seu envio para execução e anterior à quaisquer execuções;
  • PARTIAL_FILLED: Ocorreu uma execução parcial da ordem e ainda restam execuções a serem feitas;
  • FILLED: A ordem foi totalmente executada, tornando-se inativa (quantidade de ações restantes em quantidade inferior ao lote padrão serão desprezadas);
  • PENDING_CANCEL: O pedido de cancelamento da ordem já foi enviado, mas a confirmação de seu cancelamento ainda não foi recebida;
  • CANCELLED: A ordem foi cancelada antes de ser totalmente executada, tornando-se inativa.

Definição:
on_order_status(self, exec_info)

  • exec_info: Informações completas da execução de uma ordem, carregando os campos apresentados abaixo:
    • order: Objeto da ordem que gerou a atualização.
    • id: Número de identificação da ordem.
    • log_time: Horário em que a execução da ordem foi registrada.
    • order_type: Tipo da ordem (market, limit, etc.).
    • side: Tipo de operação da ordem (SHORT_SELL, SELL, BUY, BUY_COVER).
    • limit: Preço de limit (caso se aplique).
    • average_executed_price: Preço médio de execuçãoda ordem.
    • size: Tamanho do lote da ordem.
    • remaining_size: Tamanho restante do lote.
    • amount: Volume financeiro da ordem.
    • remaining_amount: Volume financeiro restante da ordem.
    • status: Status da ordem.
    • executed_price: Preço unitário no qual a ordem foi executada.
    • executed_size: Tamanho do lote da ordem que foi executada.
    • executed_amount: Valor monetário da ordem que foi executada.
    • commission: Taxa de comissão da ordem.
    • cancel_reject_reason: Razão pela qual a ordem foi cancelada ou rejeitada (caso se aplique).

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
from dorothy import StrategyBase, data, order, position

class Strategy(StrategyBase):
    """
    Essa estratégia solicita dados de preço do papel ABEV3 e, em seguida, investe todo o capital disponível no papel. As atualizações da ordem enviadas são recebidas no método on_order_status.
    """

    def on_init(self, settings):
        self.instrumento = data.subscribe.price_bar('ABEV3')

        order.send.market(
            instrument=self.instrumento,
            amount=position.cash(total=True),
        )

    def on_order_status(self, exec_info):
        # Mostra todos os dados de exec_info no log
        print(exec_info)

on_corporate_action()

Descrição:
Evento a ser chamado toda vez que um instrumento assinado tiver eventos corporativos, relatando os ajustes no seu preço e volume. Se o instrumento em questão tiver sido assinado sem ajustes (adjusted=False), esse evento trará automaticante os ajustes nas posições, ordens e capital (em caso de dividendos) do ativo em questão. Caso a assinatura tenha sido feita com ajustes (adjusted=True) e o evento trouxer ajustes no volume do ativo, o lot_size do instrumento será ajustado para compensar o volume financeiro mínimo negociável.

Definição:
on_corporate_action(self, adjustment)

  • adjustment: Objeto com informações dos ajustes que entram em efeito após o evento corporativo:
    • instrument: Instrumento que foi ajustado.
    • time: Horário em que o ajuste entrou em efeito.
    • price_factor: Fator de ajuste que multiplica os preços.
    • volume_factor: Fator de ajuste que multiplica os volumes.

Exemplo:

1
2
3
4
5
6
7
8
9
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        self.ativo = data.subscribe.price_bar('ABEV3')

    def on_corporate_action(self, adjustment):
        # Mostrando informações do ajuste no log da estratégia
        print(adjustment)

on_macro_update()

Descrição:
Evento a ser chamado quando uma variável macroeconômica assinada é atualizada.

Definição:
on_macro_update(self, update)

  • update: Atualização da variável macroeconômica que gerou o evento. Contém os seguntes campos:
    • instrument: Instrumento que foi atualizado.
    • time: Horário em que a atualização foi recebida pela plataforma.
    • value: Valor atualizado.
    • reference_date: Data a que a atualização se refere.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    ...

    def on_macro_update(self, update):
        # Se o CDI diminuiu, compre o ativo
        if 'CDI' in update.instrument.symbol:
            if cdi_antigo > update.value:
                order.send.market(instrument=self.instr, side=order.fields.side.BUY, size=1000)
            cdi_antigo = update.value

on_news()

Descrição:
Evento a ser chamado na chegada de novos dados de notícias.

Definição:
on_news(self, news)

  • news: Dados da notícia.

Exemplo:

1
2
3
4
5
6
7
8
from dorothy import StrategyBase, data

class Strategy(StrategyBase):

    ...

    def on_news(self, news):
        print(news)

on_day_close()

Descrição:
Evento chamado ao final de cada dia (fechamento de bolsa).

Definição:
on_day_close(self)

Exemplo:

1
2
3
4
5
6
7
8
from dorothy import StrategyBase, data, time

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        time.destroy_schedules()  # cancelando scheduled functions ao final de cada dia

on_exit()

Descrição:
Evento a ser chamado uma única vez no final da execução da estratégia. Pode ser utilizado, por exemplo, para calcular métricas customizadas da estratégia após o fim da execução.

Definição:
on_exit(self)

Exemplo:

1
2
3
4
5
6
7
8
9
from dorothy import StrategyBase, data, order, time

class Strategy(StrategyBase):

    ...

    def on_exit(self):
        time.destroy_schedules()
        order.cancel()  # Cancela todas as ordens ativas

Settings

settings general

Permite acesso às configurações gerais da execução:

  • settings.general.risk_free_rate: Número em percentual ou string (referência a um índice), default 0.
    • Taxa livre de risco (utiliza-se normalmente os valores de taxas de referência, como o CDI). Irá influenciar apenas o cálculo de alguns KPIs, como o sharpe e o sortino. Se for uma string referenciando um índice, será tomada a taxa média do período de execução.
  • settings.general.max_num_orders: Número inteiro, default None (sem limite).
    • Número máximo tolerado de ordens ativas simultaneamente.
  • settings.general.benchmark: String, default None.
    • Benchmark com o qual os resultados da execução serão comparados.
  • settings.general.base_yield: String ou dicionário, default None.
    • Especifica a alocação do capital parado (caixa e shorts) em um índice (CDI, por exemplo). Se for uma string, somente capital na moeda base será alocado. Um dicionário pode ser passado como argumento, especificando uma alocação para cada moeda parada (e.g., {'BRL': 'CDI', 'USD': 'LIBOR'}). A atualização do capital parado é feita a cada fechamento de mercado.
  • settings.general.base_yield_short_only: Bool ou dicionário, default False.
    • Se True, o base_yield somente será aplicado ao capital que estiver em operações de short e margens correspondentes. Se False, também haverá aplicação do capital parado em conta. Se for um valor True ou False em vez de um dicionário, o settings será válido para todas as moedas.
  • settings.general.receive_outliers: Bool, default False.
    • Se False, a estratégia não receberá barras de preço que a plataforma identificar como inválidas (devido a grandes distorções com relação à última barra, possivelmente causadas por erros na geração dos dados). Se True, todas as barras serão recebidas (a platform ainda irá desconsiderar as barras para todos os processos internos).

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Strategy(StrategyBase):
    def on_init(self, settings):

        # Configurações
        settings.general.risk_free_rate = 'CDI'
        settings.general.max_num_orders = 100  # Só serão permitidas 100 ordens ativas simultaneamente
        settings.general.benchmark = 'IBOV'  # Resultados serão comparados com o índice IBOV
        settings.general.base_yield = {'BRL': 'CDI', 'USD': 'LIBOR'}  # Capital parado em real (BRL) será atualizado com CDI e em dólar (USD) será atualizado com LIBOR.
        settings.general.base_yield_short_only = {'BRL': True, 'USD': False}  # Capital bloqueado (short) em real (BRL) será atualizado com CDI. Capital parado e bloqueado em dólar (USD) será atualizado com LIBOR.
        settings.general.receive_outliers = True


settings cost

Usado para incluir custos transacionais e de posição durante a execução da estratégia.

Os custos serão acumulados se os métodos de configuração de custos (.add) forem invocados múltiplas vezes. Para resetar os custos para zero, deve-se usar o método .reset() (e.g.: settings.cost.commission.reset()). Para consultar os valores já configurados, deve-se usar a propriedade .values (e.g.: print(settings.cost.commission.values)).


cost commission

Descrição:
Usado para incluir custos transacionais (comissão) durante a execução da estratégia. Para adicionar novas especificações de comissão, o método add deve ser chamado, conforme mostrado a seguir.

Chamada:
settings.cost.commission.add(exchanges, fee, by_size, by_amount, fixed)

  • exchanges: Default 'ALL' (para uma configuração padrão para todas as bolsas).
    • Lista de strings de bolsas.
  • instrument_types: Default 'ALL' (para uma configuração padrão para todos os tipos de ativos).
    • Lista de strings de tipos de ativos.
  • fee: Número inteiro ou string, default 0.
    • Taxa de comissão.
  • by_size: bool, default False.
    • Se True, a comissão de uma ordem será calculada pela quantidade de ações envolvidas.
  • by_amount: bool, default False.
    • Se True, a comissão de uma ordem será calculada por seu volume (financeiro).
  • fixed: bool, default False.
    • Se True, a comissão de uma ordem será um valor fixo.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
class Strategy(StrategyBase):
    def on_init(self, settings):

        # Assumindo configuração sugerido para o cenário brasileiro
        settings.default_set = 'BR'

        # Anulando configuração sugerida de custos de comissão
        settings.cost.commission.reset()

        # Adicionando configurações de custos de comissão próprias
        # fee = 15.0 bps (= 0.15%)
        # by_amount = True
        settings.cost.commission.add(fee='15bps', by_amount=True)


cost cash_carry

Descrição:
Usado para incluir custos de posição (carrego) durante toda a execução da estratégia. Para adicionar novas especificações de carrego, o método add deve ser chamado, conforme mostrado a seguir.

Chamada:
settings.cost.cash_carry.add(exchanges, rate, index, plus, margin)

  • exchanges: Default 'ALL' (para uma configuração padrão para todas as bolsas).
    • Lista de strings de bolsas.
  • rate: String do número em bps (1 bps = 0.01%), em percentual ou inteiro, default 0.
    • Taxa do índice que será utilizado para cálculo da taxa de carrego do dinheiro investido (aplicada ao final de cada dia).
  • index: String, default None.
    • Índice utilizado para cálculo da taxa de carrego (por exemplo, 'CDI').
  • plus: String do número em bps (1 bps = 0.01%), em percentual ou inteiro, default 0.
    • Acréscimo à taxa do índice que será utilizado para cálculo da taxa de carrego.
  • margin: String do número em bps (1 bps = 0.01%), em percentual ou inteiro, default 1.
    • Margem de carrego aplicada ao final de cada dia.

Exemplo:

1
2
3
4
5
6
7
8
class Strategy(StrategyBase):
    def on_init(self, settings):

        # Incluindo configurações de custos de carrego para a BMF
        settings.cost.cash_carry.add(exchanges='BMF', rate='100%', index='CDI', margin='30%')

        # Incluindo configurações de custos de carrego para a NYSE
        settings.cost.cash_carry.add(exchanges='NSE', rate='100%', index='LIBOR', margin='30%', plus='0.4%')


cost borrow

Descrição:
Usado para incluir custos transacionais de aluguel (gerados por posições short) durante a execução da estratégia. Para adicionar novas especificações de aluguel, o método add deve ser chamado, conforme mostrado a seguir.

Chamada:
settings.cost.borrow.add(exchanges, rate, index, plus)

  • exchanges: Default 'ALL'.
    • Lista de strings de bolsas.
  • rate: String do número em bps (1 bps = 0.01%), em percentual ou inteiro, default 0.
    • Taxa do índice que será utilizado para cálculo da taxa de aluguel (aplicada em short sells ao final de cada dia).
  • index: String, default None.
    • Índice utilizado para cálculo da taxa de aluguel (por exemplo, 'CDI').
  • plus: String do número em bps (1 bps = 0.01%), em percentual ou inteiro, default 0.
    • Acréscimo à taxa do índice que será utilizado para cálculo da taxa de aluguel.

Exemplo:

1
2
3
4
5
class Strategy(StrategyBase):
    def on_init(self, settings):

        # Configurações de custos de aluguel
        settings.cost.borrow.add(rate='5bps') # 5bps = 0.05%


settings execution

Usado para configurar o simulador de execução.

  • settings.execution.slippage: Número em bps (1 bps = 0.01%'), default 0.
    • Distorção no preço contra a ordem gerada (ordens de compra ficarão mais caras e de venda ficarão mais baratas). É utilizada para prever perdas por latência e dar certa margem de segurança à simulação da estratégia.
  • settings.execution.percent_of_volume: Número em percentual, default 100.
    • Porcentagem do volume da barra que pode ser executada pelo usuário na simulação.
  • settings.execution.volume_impact: Número em bps (1bps = 0.01%), default 0.
    • Simula o efeito do volume da ordem no preço do ativo, piorando o preço conforme este parâmetro e a fração de volume disponível para trade que foi executada.
  • settings.execution.volume_impact_decay: String temporal, default 0.
    • Especifica em quanto tempo o impacto causado por uma ordem nos preços cairá pela metade.

Exemplo:

1
2
3
4
5
6
7
8
class Strategy(StrategyBase):
    def on_init(self, settings):

        # Configurações de execução
        settings.execution.slippage = 5.0  # bps (1bps = 0.01%)
        settings.execution.percent_of_volume = 30  # 30% (0% <-> 100%)
        settings.execution.volume_impact = 10  # 10% (0% <-> 100%)
        settings.execution.volume_impact_decay = '3D'  # O impacto atingirá a metade do seu valor a cada 3 dias


settings risk

Usado para configurar parâmetros de gestão de risco da estratégia.

  • settings.risk.cancel_insufficient_capital_orders: bool, default True.
    • Se True, as ordens (já enviadas para execução) que tentarem executar gastos de capital além do possuído serão executadas até o limite de capital e então canceladas. Se False, as ordens serão executadas independentemente do capital, permitindo que fique negativo.
  • settings.risk.max_position: Número, default None.
    • Limita o volume financeiro máximo que pode ser investido na estratégia (avaliado na moeda base da estratégia).
  • settings.risk.stop_loss: Número em percentual, default None.
    • Se a estratégia atingir o retorno negativo neste valor, todas as posições serão fechadas e a estratégia cancelada, de forma a limitar seu risco.
  • settings.risk.allow_bankrupt: bool, default True.
    • Determina se a plataforma irá cancelar a estratégia ou não ao ser atingido capital nulo. Por exemplo, se este parâmetro estiver desativado e for executada uma ordem de compra com valor superior ao capital possuído, a estratégia será encerrada. Caso contrário, a estratégia operaria normalmente com capital negativo, podendo gerar indicadores de performance anômalos.

Exemplo:

1
2
3
4
5
6
7
8
class Strategy(StrategyBase):
    def on_init(self, settings):

        # Configurações de gestão de risco
        settings.risk.cancel_insufficient_capital_orders = True
        settings.risk.max_position = 1000000 # $ 1,000,000
        settings.risk.stop_loss = 10 # 10% (0% <-> 100%)
        settings.risk.allow_bankrupt = True # True or False


settings default_set

Carrega o conjunto de settings especificado. O uso de um default set somente alterará os campos que a estratégia ainda não tiver configurado. Os campos setados pelo default_set ainda podem ser alterados pela estratégia. Para consultar os default sets disponíveis, basta printar settings.default_set.

Example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
class Strategy(StrategyBase):
    def on_init(self, settings):

        # Settings
        # Selecting default set of Brazil
        settings.default_set = 'BR'

        # Applying default set of volulme impact
        settings.default_set = 'impact'

        # Changing stop loss setting for other value
        settings.risk.stop_loss = 40 # Strategy will be closed and finished if return reaches -40%

Instrumentos

Os instrumentos são os blocos de informação básicos da plataforma. Eles centralizam as funcionalidades e informações específicas de cada entidade nas execuções.

As funções da plataforma aceitam como referências aos instrumentos primariamente os próprios objetos, mas compreendem também seus símbolos (strings), fazendo a inferência quanto a que instrumento a estratégia está se referindo. A melhor prática, no entanto, é o uso dos instrumentos diretamente, dado que evita possíveis problemas com instrumentos de símbolo parecido (e.g.: negociação de pares idênticos de moedas em diferentes bolsas).

Os seguintes instrumentos são disponibilizados na plataforma:


Country

Instrumento que carrega as funcionalidades e informações de países na plataforma. Contém os seguintes campos:

  • exchanges: lista de bolsas ativas no país;
  • indexes: lista de índices ativos no país;
  • macros: lista de variáveis macroeconômicas ativas no país;
  • name: nome do país;
  • reference_exchange: bolsa de referência do país (usada para regular calendários de índices, por exemplo);
  • subscribed_indexes: índices assinados pertencentes ao país;
  • subscribed_macros: variáveis macroeconômicas assinadas pertencentes ao país;
  • symbol: símbolo do país;
  • type: tipo do instrumento (possui valor 'COUNTRY');

Currency

Instrumento que carrega as funcionalidades e informações de moedas na plataforma. Contém os seguintes campos:

  • symbol: Símbolo da moeda;
  • balance: saldo da moeda; considera o caixa parado, o capital recebido (e bloqueado) em operações de short e suas margens;
  • capital_available_for_short_margin: capital disponível para alocação em margens de short;
  • capital_in_short_margin: capital alocado em margens de short;
  • cash: caixa parado na moeda;
  • best_case_cash: caixa hipotético no caso em que apenas as execuções de ordens ativas que aumentam o caixa ocorrem;
  • worst_case_cash: caixa hipotético no caso em que apenas as execuções de ordens ativas que reduzem o caixa ocorrem;
  • source_fx: lista de instrumentos de FX que possuem a moeda como fonte de operação;
  • destination_fx: lista de instrumentos de FX que possuem a moeda como destino de operação;
  • equities: lista de instrumentos de equity que operam nesta moeda;
  • initial_capital: capital inicial alocado na moeda;
  • is_base: True se essa for a moeda base da execução; False em caso contrário;
  • market_value: Valor mais atual alocado em ativos na moeda;
  • long_market_value: Valor mais atual alocado em operações long de ativos na moeda;
  • short_market_value: Valor mais atual alocado em operações short de ativos na moeda;
  • pnl: Saldo das operações na moeda. Equivale ao total_capital subtraído do capital inicial na moeda.
  • stocks_allowance_in_short_margin: Fração do valor alocado em equities que pode ser utilizado como margem em operações de short;
  • total_capital: Capital total alocado na moeda e seus ativos. Equivale ao balance somado ao market_value;
  • type: tipo do instrumento (possui valor 'CURRENCY');
  • convert: método que converte um valor para outra moeda. Retorna None se a conversão não for possível. Recebe os seguintes parâmetros:
    • to_currency: instrumento de moeda;
      • Indica para qual moeda o valor será convertido;
    • value: lista de números, default 1;
      • Indica que valores deverão ser convertidos;
      • None pode ser enviado para acessar o valor em caixa da moeda;
    • direct: bool, default True;
      • Informa se apenas uma conversão direta deverá será aceita (executa mais rapidamente);
    • min_price: bool, default True;
      • Se direct=False, a conversão será realizada pelo caminho de menor preço; caso contrário, será realizada pelo caminho de maior preço;
    • subscribed_fx_only: bool, default True;
      • Só pode ser False se direct=False;
      • Se True, a busca de FX para conversão entre as duas moedas se limitará a ativos assinados; caso contrário, ativos não assinados serão consultados (implica em perda considerável de desempenho devido à múltiplos acessos à base de preços);
  • convertion_rate: método para obter a taxa de conversão para outra moeda. Retorna None se a conversão não for possível. Recebe os seguintes parâmetros:
    • to_currency: instrumento de moeda;
      • Indica para qual moeda o valor será convertido;
    • direct: bool, default True;
      • Informa se apenas uma conversão direta deverá será aceita (executa mais rapidamente);
    • min_price: bool, default True;
      • Se direct=False, a conversão será realizada pelo caminho de menor preço; caso contrário, será realizada pelo caminho de maior preço;
    • subscribed_fx_only: bool, default True;
      • Só pode ser False se direct=False;
      • Se True, a busca de FX para conversão entre as duas moedas se limitará a ativos assinados; caso contrário, ativos não assinados serão consultados (implica em perda considerável de desempenho devido à múltiplos acessos à base de dados);

Exchange

Instrumento que carrega as funcionalidades e informações de bolsas na plataforma. Contém os seguintes campos:

  • country: país da bolsa;
  • name: nome da bolsa;
  • non_stop: informa se a bolsa funciona continuamente (True) ou se possui horários limitados de funcionamento;
  • data_start: data inicial dos dados da bolsa na base de dados;
  • equities: lista de equities ativas na bolsa;
  • fx: lista de FX ativas na bolsa;
  • subscribed_equities: lista de equities assinados na bolsa;
  • subscribed_fx: lista de FX assinadas na bolsa;
  • symbol: símbolo da bolsa;
  • type: tipo do instrumento (possui valor 'EXCHANGE');

Macro

Instrumento que carrega as funcionalidades e informações de variáveis macroeconômicas na plataforma. Contém os seguintes campos:

  • symbol: símbolo da variável macroeconômica;
  • name: nome da variável macroeconômica;
  • country: país da variável macroeconômica;
  • data_fields: informa os campos disponíveis nos dados da variável macroeconômica;
  • frequency: informa a frequência de divulgação da variável macroeconômica;
  • latest_data_object: objeto de dados mais recente da variável macroeconômica;
  • latest_value: valor mais recente da variável macroeconômica;
  • lookback_length: comprimento de lookback disponível no instrumento da variável macroeconômica;
  • source: fonte de dados da variável macroeconômica;
  • start: início da séries de dados da variável macroeconômica;
  • subscribed: informa se a variável macroeconômica foi assinada (True) ou não (False);
  • unit: unidade do valor da variável macroeconômica;
  • type: tipo do instrumento (possui valor 'MACRO');
  • is_equity: informa se o instrumento é uma equity (retorna False);
  • is_fx: informa se o instrumento é uma FX (retorna False);
  • is_index: informa se o instrumento é um índice (retorna False);
  • is_macro: informa se o instrumento é uma variável macroeconômica (retorna True);
  • is_tradable: informa se o instrumento é negociável (retorna False);
  • lookback: método que recupera dados históricos da janela de lookback da variável macroeconômica. Por default, retorna um dicionário com as listas de campos desejados. Recebe os seguintes parâmetros:
    • fields: lista de strings, default None (retorna todos os campos disponíveis);
      • Define que campos de dados serão recuperados da janela de lookback;
      • Os campos disponíveis constam na propriedade data_fields do instrumento;
    • dataframe: bool, default False;
      • Se True o retorno será gerado em formato de pandas.DataFrame;
    • data_object: bool, default False;
      • Se True, o método irá retornar objetos de dados (os mesmos que são recebidos a cada evento);
  • hist: método que recupera dados históricos da variável macroeconômica. Se for possível recuperar dados suficientes diretamente do lookback do instrumento, este método não recorrerá à base de dados, elevando a velocidade de execução. Recebe os seguintes parâmetros:
    • length: Número inteiro, string temporal ou datetime.timedelta;
      • Indica o tamanho da série histórica desejada;
      • Se for um número inteiro, serão buscados os últimos length objetos de dados na base; Se for uma string temporal ou datetime.timedelta, serão buscados dados na janela histórica indicada;
    • data_object: bool, default False;
      • Se True, o método irá retornar objetos de dados (os mesmos que são recebidos a cada evento); Se False, um objeto pandas.DataFrame será retornado com os dados requeridos;
  • subscribe: método para assinar o instrumento:
    • lookback_length: Número inteiro ou datetime.timedelta, default 0.
      • Este parâmetro define o tamanho da janela de lookback, ou seja, a janela de dados anteriores ao cursor de tempo da estratégia que será mantida disponível no campo lookback dos instrumentos assinados. Se for um inteiro, o número definido de últimas observações será mantido. Se for definido como datetime.timedelta, as observações no período definido mais recente serão mantidas.
  • unsubscribe: método para cancelar a assinatura do instrumento.

Index

Instrumento não negociável de barra de preços que carrega as funcionalidades e informações de índices na plataforma. Contém os seguintes campos:

  • symbol: símbolo do índice;
  • ticker: informa o código do índice no país;
  • tick: informa a unidade mínima de contabilização do valor do índice;
  • frequency: frequência com que o ativo foi assinado (ou None se o ativo não foi assinado);
  • country: país do índice;
  • exchange: bolsa de referência do índice;
  • currency: moeda do índice;
  • members: retorna um dicionário com os membros atuais do índice e seus pesos (se disponíveis);
  • data_fields: informa os campos disponíveis nos dados do índice;
  • latest_data_object: objeto de dados (barra de preços) mais recente do índice;
  • latest_value: valor mais recente do índice (VWAP, caso esteja disponível, senão (open + high + low + close) / 4);
  • lookback_length: comprimento de lookback disponível no instrumento do índice;
  • subscribed: informa se o índice foi assinado (True) ou não (False);
  • type: tipo do instrumento (possui valor 'INDEX');
  • is_equity: informa se o instrumento é uma equity (retorna False);
  • is_fx: informa se o instrumento é uma FX (retorna False);
  • is_index: informa se o instrumento é um índice (retorna True);
  • is_macro: informa se o instrumento é uma variável macroeconômica (retorna False);
  • is_tradable: informa se o instrumento é negociável (retorna False);
  • lookback: método que recupera dados históricos da janela de lookback do índice. Por default, retorna um dicionário com as listas de campos desejados. Recebe os seguintes parâmetros:
    • fields: lista de strings, default None (retorna todos os campos disponíveis);
      • Define que campos de dados serão recuperados da janela de lookback;
      • Os campos disponíveis constam na propriedade data_fields do instrumento;
    • dataframe: bool, default False;
      • Se True o retorno será gerado em formato de pandas.DataFrame;
    • data_object: bool, default False;
      • Se True, o método irá retornar objetos de dados (os mesmos que são recebidos a cada evento);
    • frequency: Número ou string temporal, default None (assume-se a frequência base da estratégia);
      • Especifica a frequência dos dados requisitados;
      • Se numérico, será assumida a unidade de segundos;
  • hist: método que recupera dados históricos do índice. Se for possível recuperar dados suficientes diretamente do lookback do instrumento, este método não recorrerá à base de dados, elevando a velocidade de execução. Recebe os seguintes parâmetros:
    • length: Número inteiro, string temporal ou datetime.timedelta;
      • Indica o tamanho da série histórica desejada;
      • Se for um número inteiro, serão buscados os últimos length objetos de dados na base; Se for uma string temporal ou datetime.timedelta, serão buscados dados na janela histórica indicada;
    • data_object: bool, default False;
      • Se True, o método irá retornar objetos de dados (os mesmos que são recebidos a cada evento); Se False, um objeto pandas.DataFrame será retornado com os dados requeridos;
    • frequency: Número ou string temporal, default None (assume-se a frequência base da estratégia);
      • Especifica a frequência dos dados requisitados;
      • Se numérico, será assumida a unidade de segundos;
  • subscribe: método para assinar o instrumento:
    • lookback_length: Número inteiro ou datetime.timedelta, default 0.
      • Este parâmetro define o tamanho da janela de lookback, ou seja, a janela de dados anteriores ao cursor de tempo da estratégia que será mantida disponível no campo lookback dos instrumentos assinados. Se for um inteiro, o número definido de últimas observações será mantido. Se for definido como datetime.timedelta, as observações no período definido mais recente serão mantidas.
    • frequency: Número ou string temporal, default None (assume-se a frequência base da estratégia);
      • Especifica a frequência dos dados requisitados;
      • Se numérico, será assumida a unidade de segundos;
  • unsubscribe: método para cancelar a assinatura do instrumento.

FX

Instrumento negociável de barra de preços que carrega as funcionalidades e informações de FX (instrumento de câmbio entre moedas) na plataforma. Pode-se considerar o FX como o instrumento que usa source_currency para comprar o ativo destination_currency. Contém os seguintes campos:

  • symbol: símbolo da FX; é formado pelo símbolo da moeda de destino seguido do símbolo da moeda de origem (e.g.: 'USDBRL' possui moeda de destino USD e moeda de origem BRL);
  • ticker: código da FX na bolsa;
  • tick: unidade mínima de contabilização do valor da FX;
  • frequency: frequência com que o ativo foi assinado (ou None se o ativo não foi assinado);
  • country: país da bolsa da FX;
  • exchange: bolsa em que a FX é negociada;
  • currency: moeda de origem da FX;
  • data_fields: informa os campos disponíveis nos dados da FX;
  • latest_data_object: objeto de dados (barra de preços) mais recente da FX;
  • latest_value: valor mais recente da FX (VWAP, caso esteja disponível, senão (open + high + low + close) / 4);
  • lookback_length: comprimento de lookback disponível no instrumento da FX;
  • subscribed: informa se a FX foi assinada (True) ou não (False);
  • source_currency: moeda de origem do instrumento; é a moeda alvo do parâmetro amount das ordens de FX (amount=1000 significa "gaste 1000 {source currency} para conseguir {destination currency} e amount=-1000 significa "venda {destination currency} para conseguir 1000 {source currency})");
  • destination_currency: moeda de destino do instrumento; é a moeda alvo do parâmetro size das ordens de FX (size=1000 significa "gaste {source currency} para conseguir 1000 {destination currency} e size=-1000 significa "venda 1000 {destination currency} para conseguir {source currency})");
  • balance: saldo realizado do instrumento, ou seja, resultado das transmissões de caixa (compra e venda) pelo instrumento na moeda fonte;
  • pnl: resultado geral (perdas ou ganhos) das operações no instrumento; equivale ao balance da moeda fonte somado ao balance da moeda de destino multiplicado pela taxa de conversão mais recente;
  • long: True se o balance da moeda fonte for positivo, False em caso contrário;
  • short: True se o balance da moeda fonte for negativo, False em caso contrário;
  • neutral: True se o balance da moeda fonte for nulo, False em caso contrário;
  • commission: comissão total paga em negociações pelo instrumento;
  • active_orders: lista de ordens ativas no instrumento;
  • has_active_orders: True se existirem ordens ativas no instrumento, False em caso contrário;
  • best_case_cash_shift: diferença hipotética no caixa no caso em que apenas as execuções de ordens ativas que aumentam o caixa da moeda de origem ocorrem;
  • worst_case_cash_shift: diferença hipotética no caixa no caso em que apenas as execuções de ordens ativas que reduzem o caixa da moeda de origem ocorrem;
  • type: tipo do instrumento (possui valor 'FX');
  • is_equity: informa se o instrumento é uma equity (retorna False);
  • is_fx: informa se o instrumento é uma FX (retorna True);
  • is_index: informa se o instrumento é um índice (retorna False);
  • is_macro: informa se o instrumento é uma variável macroeconômica (retorna False);
  • is_tradable: informa se o instrumento é negociável (retorna True);
  • lookback: método que recupera dados históricos da janela de lookback da FX. Por default, retorna um dicionário com as listas de campos desejados. Recebe os seguintes parâmetros:
    • fields: lista de strings, default None (retorna todos os campos disponíveis);
      • Define que campos de dados serão recuperados da janela de lookback;
      • Os campos disponíveis constam na propriedade data_fields do instrumento;
    • dataframe: bool, default False;
      • Se True o retorno será gerado em formato de pandas.DataFrame;
    • data_object: bool, default False;
      • Se True, o método irá retornar objetos de dados (os mesmos que são recebidos a cada evento);
    • frequency: Número ou string temporal, default None (assume-se a frequência base da estratégia);
      • Especifica a frequência dos dados requisitados;
      • Se numérico, será assumida a unidade de segundos;
  • hist: método que recupera dados históricos da FX. Se for possível recuperar dados suficientes diretamente do lookback do instrumento, este método não recorrerá à base de dados, elevando a velocidade de execução. Recebe os seguintes parâmetros:
    • length: Número inteiro, string temporal ou datetime.timedelta;
      • Indica o tamanho da série histórica desejada;
      • Se for um número inteiro, serão buscados os últimos length objetos de dados na base; Se for uma string temporal ou datetime.timedelta, serão buscados dados na janela histórica indicada;
    • data_object: bool, default False;
      • Se True, o método irá retornar objetos de dados (os mesmos que são recebidos a cada evento); Se False, um objeto pandas.DataFrame será retornado com os dados requeridos;
    • frequency: Número ou string temporal, default None (assume-se a frequência base da estratégia);
      • Especifica a frequência dos dados requisitados;
      • Se numérico, será assumida a unidade de segundos;
  • subscribe: método para assinar o instrumento:
    • lookback_length: Número inteiro ou datetime.timedelta, default 0.
      • Este parâmetro define o tamanho da janela de lookback, ou seja, a janela de dados anteriores ao cursor de tempo da estratégia que será mantida disponível no campo lookback dos instrumentos assinados. Se for um inteiro, o número definido de últimas observações será mantido. Se for definido como datetime.timedelta, as observações no período definido mais recente serão mantidas.
    • frequency: Número ou string temporal, default None (assume-se a frequência base da estratégia);
      • Especifica a frequência dos dados requisitados;
      • Se numérico, será assumida a unidade de segundos;
  • unsubscribe: método para cancelar a assinatura do instrumento.

Equity

Instrumento negociável de barra de preços que carrega as funcionalidades e informações de equity (ações de empresas abertas) na plataforma. Contém os seguintes campos:

  • symbol: símbolo da equity;
  • ticker: código da equity na bolsa;
  • tick: unidade mínima de contabilização do valor da equity;
  • frequency: frequência com que o ativo foi assinado (ou None se o ativo não foi assinado);
  • country: país da bolsa da equity;
  • exchange: bolsa em que a equity é negociada;
  • currency: moeda de operação da equity;
  • data_fields: informa os campos disponíveis nos dados da equity;
  • latest_data_object: objeto de dados (barra de preços) mais recente da equity;
  • latest_value: valor mais recente da equity (VWAP, caso esteja disponível, senão (open + high + low + close) / 4);
  • lookback_length: comprimento de lookback disponível no instrumento da equity;
  • subscribed: informa se a equity foi assinada (True) ou não (False);
  • balance: saldo realizado do instrumento, ou seja, resultado das transmissões de caixa (compra e venda) pelo instrumento na moeda fonte;
  • pnl: resultado geral (perdas ou ganhos) das operações no instrumento; equivale ao balance da moeda fonte somado ao balance da moeda de destino multiplicado pela taxa de conversão mais recente;
  • long: True se o balance da moeda fonte for positivo, False em caso contrário;
  • short: True se o balance da moeda fonte for negativo, False em caso contrário;
  • neutral: True se o balance da moeda fonte for nulo, False em caso contrário;
  • active_orders: lista de ordens ativas no instrumento;
  • has_active_orders: True se existirem ordens ativas no instrumento, False em caso contrário;
  • best_case_cash_shift: diferença hipotética no caixa no caso em que apenas as execuções de ordens ativas que aumentam o caixa da moeda de origem ocorrem;
  • worst_case_cash_shift: diferença hipotética no caixa no caso em que apenas as execuções de ordens ativas que reduzem o caixa da moeda de origem ocorrem;
  • borrow: custo de aluguel pago em manutenção de posições short no instrumento;
  • cash_carry: custo de carrego (alocação interdiário de caixa) pago na manutenção de posições no instrumento;
  • commission: comissão total paga em negociações com o instrumento;
  • adjusted: informa se o instrumento foi assinado como ajustado (returna None se o instrumento não foi assinado);
  • adjustments: pandas.DataFrame com os ajustes passados do instrumento;
  • amount: volume financeiro investido no instrumento;
  • size: quantidade de ações possuída do instrumento;
  • outstanding_amount: volume financeiro pendente de execução nas ordens ativas deste instrumento;
  • outstanding_size: quantidade de ações pendente de execução nas ordens ativas deste instrumento;
  • expected_amount: capital total que se espera ter investido no instrumento após a execução de todas as ordens pendentes;
  • expected_size: quantidade de ações total que se espera ter do instrumento após a execução de todas as ordens pendentes;
  • lot_size: quantidade mínima de ações que pode ser negociada por vez do instrumento;
  • cost: custo da posição; equivale ao capital gasto para criar a posição mais o consumo de capital por margem de short. Se o instrumento já tiver realizado algum lucro, o custo será nulo;
  • capital_in_short_margin: capital alocado em margem de operações short;
  • industry: indústria do instrumento;
  • sector: setor do instrumento;
  • multiplier: Equivalência de quantidade de ações desse instrumento com relação ao instrumento base (normalmente é diferente de um quando o instrumento possui uma versão negociada no exterior);
  • instrument_chain: lista contendo a sequência de instrumentos relacionados a esse por renomeação de ticker;
  • subscribed_linked_instrument: instrumento da instrument_chain que está assinado; None se nenhum instrumento da lista está assinado;
  • old_instrument: instrumento que antecede este na sequência de renomeações do instrument_chain; None se este for o primeiro instrumento da sequência;
  • new_instrument: instrumento que sucede este na sequência de renomeações do instrument_chain; None se este for o instrumento mais recente da sequência;
  • ticker_start: data em que o último instrumento foi renomeado e o old_instrument deixou de operar; None se o instrumento é o primeiro da sequência de renomeações;
  • ticker_end: data em que o instrumento foi renomeado e o new_instrument passou a operar; None se o instrumento ainda está ativo;
  • price_factor: fator acumulado de ajuste de preços por eventos corporativos neste instrumento; é o fator que multiplica o preço bruto para chegar ao valor ajustado;
  • volume_factor: fator acumulado de ajuste de volumes por eventos corporativos neste instrumento; é o fator que multiplica o volume bruto para chegar ao valor ajustado;
  • short_margin: margem consumida nas operações de short neste instrumento, isto é, fração do valor total alocado em short que será consumida do capital como forma de garantia contra movimentações positivas de preço;
  • shortable: True se o instrumento pode realizar operações de short, isto é, se pode registrar quantidade de ações (size) negativa;
  • type: tipo do instrumento (possui valor 'EQUITY');
  • is_equity: informa se o instrumento é uma equity (retorna True);
  • is_fx: informa se o instrumento é uma FX (retorna False);
  • is_index: informa se o instrumento é um índice (retorna False);
  • is_macro: informa se o instrumento é uma variável macroeconômica (retorna False);
  • is_tradable: informa se o instrumento é negociável (retorna True);
  • lookback: método que recupera dados históricos da janela de lookback da equity. Por default, retorna um dicionário com as listas de campos desejados. Recebe os seguintes parâmetros:
    • fields: lista de strings, default None (retorna todos os campos disponíveis);
      • Define que campos de dados serão recuperados da janela de lookback;
      • Os campos disponíveis constam na propriedade data_fields do instrumento;
    • dataframe: bool, default False;
      • Se True o retorno será gerado em formato de pandas.DataFrame;
    • data_object: bool, default False;
      • Se True, o método irá retornar objetos de dados (os mesmos que são recebidos a cada evento);
    • frequency: Número ou string temporal, default None (assume-se a frequência base da estratégia);
      • Especifica a frequência dos dados requisitados;
      • Se numérico, será assumida a unidade de segundos;
  • hist: método que recupera dados históricos da equity. Se for possível recuperar dados suficientes diretamente do lookback do instrumento, este método não recorrerá à base de dados, elevando a velocidade de execução. Recebe os seguintes parâmetros:
    • length: Número inteiro, string temporal ou datetime.timedelta;
      • Indica o tamanho da série histórica desejada;
      • Se for um número inteiro, serão buscados os últimos length objetos de dados na base; Se for uma string temporal ou datetime.timedelta, serão buscados dados na janela histórica indicada;
    • data_object: bool, default False;
      • Se True, o método irá retornar objetos de dados (os mesmos que são recebidos a cada evento); Se False, um objeto pandas.DataFrame será retornado com os dados requeridos;
    • frequency: Número ou string temporal, default None (assume-se a frequência base da estratégia);
      • Especifica a frequência dos dados requisitados;
      • Se numérico, será assumida a unidade de segundos;
    • adjusted: bool, default None (refere-se à opção de ajuste feita na assinatura ou True se o instrumento não tiver sido assinado);
      • Especifica se os dados requisitados devem ser ajustados para compensar eventos corporativos (True) ou não (False);
  • subscribe: método para assinar o instrumento:
    • lookback_length: Número inteiro ou datetime.timedelta, default 0.
      • Este parâmetro define o tamanho da janela de lookback, ou seja, a janela de dados anteriores ao cursor de tempo da estratégia que será mantida disponível no campo lookback dos instrumentos assinados. Se for um inteiro, o número definido de últimas observações será mantido. Se for definido como datetime.timedelta, as observações no período definido mais recente serão mantidas.
    • adjusted: bool, default None (refere-se à opção de ajuste feita na assinatura ou True se o instrumento não tiver sido assinado);
      • Especifica se os dados requisitados devem ser ajustados para compensar eventos corporativos (True) ou não (False);
    • frequency: Número ou string temporal, default None (assume-se a frequência base da estratégia);
      • Especifica a frequência dos dados requisitados;
      • Se numérico, será assumida a unidade de segundos;
  • unsubscribe: método para cancelar a assinatura do instrumento.

Data

O módulo data carrega todas as ferramentas relacionadas à aquisição de dados na plataforma, executando os pedidos de assinatura e de cancelamento de assinatura de instrumentos e também de aquisição de dados históricos anteriores ao cursor de tempo da plataforma. Ele possui três submódulos:



subscribe

Permite a assinatura dos diferentes tipos de informação a serem recebidos pela estratégia.


subscribe price_bar()

Descrição:
Método usado para assinar os preços de instrumentos que a estratégia deseja receber.

Chamada:
data.subscribe.price_bar(instruments, adjusted, frequency, lookback_length)

  • instruments: Lista de instrumentos de barra de preços
    • Ativos dos quais se deseja receber preços (e.g.: 'PETR3', ['PETR3','IBOV','USDBRL']).
  • adjusted: bool, default True.
    • Este parâmetro define se os dados devem vir com seu valor ajustado por eventos corporativos (True) ou não (False).
  • frequency: String temporal, default None (refere-se a frequência base da estratégia, definida na interface).
  • lookback_length: Número inteiro ou datetime.timedelta, default 0.
    • Este parâmetro define o tamanho da janela de lookback, ou seja, a janela de dados anteriores ao cursor de tempo da estratégia que será mantida disponível no campo lookback dos instrumentos assinados. Se for um inteiro, o número definido de últimas observações será mantido. Se for definido como datetime.timedelta, as observações no período definido mais recente serão mantidas.

Retorno:
Retorna a lista de instrumentos que foram enviados no parâmetro instruments.

Exemplo:

1
2
3
4
5
6
7
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        ativos_us = data.get.symbols.equity_by_liquidity(countries='US', top=20)

        self.instrumentos = data.subscribe.price_bar(ativos_us)

subscribe macro_update()

Descrição:
Método usado para assinar os preços de variáveis macroeconômicas que a estratégia deseja receber.

Chamada:
data.subscribe.macro_update(instruments, lookback_length)

  • instruments: Lista de instrumentos de barra de preços
    • Ativos dos quais se deseja receber atualizações (e.g.: 'CDI', ['CDI','GDP']).
  • lookback_length: Número inteiro ou datetime.timedelta, default 0.
    • Este parâmetro define o tamanho da janela de lookback, ou seja, a janela de dados anteriores ao cursor de tempo da estratégia que será mantida disponível no campo lookback dos instrumentos assinados. Se for um inteiro, o número definido de últimas observações será mantido. Se for definido como datetime.timedelta, as observações no período definido mais recente serão mantidas.

Retorno:
Retorna a lista de variáveis macroeconômicas que foram enviados no parâmetro instruments.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        self.cdi = data.subscribe.macro_update('CDI')



unsubscribe

Permite o cancelamento da assinatura dos diferentes tipos de informação qeu estão sendo recebidos pela estratégia.


unsubscribe price_bar()

Descrição:
Método usado para cancelar a assinatura dos preços de instrumentos que a estratégia não deseja mais receber.

Chamada:
data.unsubscribe.price_bar(instruments)

  • instruments: Lista de instrumentos de barra de preços
    • Ativos dos quais não se deseja mais receber preços (e.g.: 'PETR3', ['PETR3','IBOV','USDBRL']).

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from dorothy import StrategyBase, data

class Strategy(StrategyBase):

    ...

    def on_day_close(self, settings):

        ...

        self.instrumentos = data.unsubscribe.price_bar(['PETR3', 'IBOV', 'USDBRL'])

unsubscribe macro_update()

Descrição:
Método usado para cancelar a assinatura dos preços de variáveis macroeconômicas que a estratégia não deseja mais receber.

Chamada:
data.unsubscribe.macro_update(instruments)

  • instruments: Lista de instrumentos de barra de preços
    • Ativos dos quais não se deseja mais receber atualizações (e.g.: 'CDI', ['CDI','GDP']).

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from dorothy import StrategyBase, data

class Strategy(StrategyBase):

    ...

    def on_day_close(self, settings):

        ...

        self.instrumentos = data.unsubscribe.macro_update('CDI')



get

Permite requisições pontuais a dados/objetos da plataforma.


get converted_currency()

Descrição:
Método usado converter valores entre duas moedas.

Chamada:
data.get.converted_currency(from_currency, to_currency, value, direct, min_price, subscribed_fx_only)

  • from_currency: Moeda.
    • Moeda no qual o valor (value) foi descrito (e.g.: 'BRL').
  • to_currency: Moeda, default None (se refere à moeda base).
    • Moeda para a qual o valor (value) deve ser convertido (e.g.: 'USD').
  • value: Lista de números, default 1;
    • Valores que devem ser convertido de from_currency para to_currency.
    • Se None for enviado, o caixa de from_currency será usado.
  • direct: bool, default True;
    • Informa se apenas uma conversão direta deverá será aceita (executa mais rapidamente);
  • min_price: bool, default True;
    • Se direct=False, a conversão será realizada pelo caminho de menor preço; caso contrário, será realizada pelo caminho de maior preço;
  • subscribed_fx_only: bool, default True;
    • Só pode ser False se direct=False;
    • Se True, a busca de FX para conversão entre as duas moedas se limitará a ativos assinados; caso contrário, ativos não assinados serão consultados (implica em perda considerável de desempenho devido à múltiplos acessos à base de preços);

Retorno:
Retorna o valor convertido.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        print(data.get.converted_currency(from_currency='USD', to_currency='BRL', value=1000))



get symbols

Agrupa os métodos utilizados para consultar símbolos de instrumentos.


get symbols equity()

Descrição:
Método usado para consultar símbolos de equities.

Chamada:
data.get.symbols.equity(exchanges, sectors, industries)

  • exchanges: Lista de bolsas, default None (se refere a todas as bolsas disponíveis).
    • Bolsas nas quais se quer consultar símbolos.
  • sectors: Lista de strings, default None (sem filtros por setor).
    • Setores dos quais se deseja extrair símbolos.
  • industries: Lista de strings, default None (sem filtros por indústria).
    • Indústrias das quais se deseja extrair símbolos.

Retorno:
Retorna o dicionário com as listas de símbolos conforme os filtros selecionados.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        symbols = data.get.symbols.equity(exchanges='B3', sectors='Financial', industries='Banks')

get symbols fx()

Descrição:
Método usado para consultar símbolos de FX.

Chamada:
data.get.symbols.fx(exchanges, currencies)

  • exchanges: Lista de bolsas, default None (se refere a todas as bolsas disponíveis).
    • Bolsas nas quais se quer consultar símbolos.
  • currencies: Lista de moedas, default None (se refere a todas as moedas disponíveis).
    • Somente os ativos que operarem as moedas selecionadas terão seus símbolos recuperados.

Retorno:
Retorna o dicionário com as listas de símbolos conforme os filtros selecionados.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        symbols = data.get.symbols.fx(exchanges='B3', currencies=['USD', 'BRL'])

get symbols index()

Descrição:
Método usado para consultar símbolos de index.

Chamada:
data.get.symbols.index(countries)

  • countries: Lista de países, default None (se refere a todos os países disponíveis).
    • Países nos quais se quer consultar índices.

Retorno:
Retorna o dicionário com as listas de símbolos conforme os filtros selecionados.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        symbols = data.get.symbols.index(countries=['BR', 'US'])

get symbols macro()

Descrição:
Método usado para consultar símbolos de variáveis macroeconômicas.

Chamada:
data.get.symbols.macro(countries)

  • countries: Lista de países, default None (se refere a todos os países disponíveis).
    • Países nos quais se quer consultar símbolos de variáveis macroeconômicas.

Retorno:
Retorna o dicionário com as listas de símbolos conforme os filtros selecionados.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        symbols = data.get.symbols.macro(countries='BR')

get symbols country()

Descrição:
Método usado para consultar símbolos de países.

Chamada:
data.get.symbols.country()

Retorno:
Retorna a lista de símbolos de países.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        symbols = data.get.symbols.country()

get symbols exchange()

Descrição:
Método usado para consultar símbolos de bolsas.

Chamada:
data.get.symbols.exchange(countries)

  • countries: Lista de países, default None (se refere a todos os países disponíveis).
    • Países nos quais se quer consultar símbolos de bolsas.

Retorno:
Retorna o dicionário com as listas de símbolos conforme os filtros selecionados.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        symbols = data.get.symbols.exchange(countries='BR')

get symbols currency()

Descrição:
Método usado para consultar símbolos de moedas.

Chamada:
data.get.symbols.currency()

Retorno:
Retorna a lista de símbolos de moedas.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        symbols = data.get.symbols.currency()

get symbols sector()

Descrição:
Método usado para consultar setores de equities.

Chamada:
data.get.symbols.sector()

Retorno:
Retorna a lista de setores.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        symbols = data.get.symbols.sector()

get symbols industry()

Descrição:
Método usado para consultar industrias de equities.

Chamada:
data.get.symbols.industry()

Retorno:
Retorna a lista de indústrias.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        symbols = data.get.symbols.industry()

get symbols equity_by_liquidity()

Descrição:
Método usado para consultar símbolos de equities em ordem de liquidez.

Chamada:
data.get.symbols.equity_by_liquidity(countries, exchanges, sectors, industries, top, bottom)

  • countries: Lista de países, default None (se refere a todos os países disponíveis).
    • Países nos quais se quer consultar índices.
  • exchanges: Lista de bolsas, default None (se refere a todas as bolsas disponíveis).
    • Bolsas nas quais se quer consultar símbolos.
  • sectors: Lista de strings, default None (sem filtros por setor).
    • Setores dos quais se deseja extrair símbolos.
  • industries: Lista de strings, default None (sem filtros por indústria).
    • Indústrias das quais se deseja extrair símbolos.
  • top: Número inteiro, default None (todos serão retornados).
    • Quantidade de símbolos do topo da lista de liquidez que serão retornados.
  • bottom: Número inteiro, default None (todos serão retornados).
    • Quantidade de símbolos do fundo da lista de liquidez que serão retornados.

Retorno:
Retorna o dicionário com as listas de símbolos conforme os filtros selecionados.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        symbols = data.get.symbols.equity_by_liquidity(countries='US', sectors='Financial', industries='Banks', top=10)

get symbols index_members()

Descrição:
Método usado para consultar símbolos de membros de índices.

Chamada:
data.get.symbols.index_members(index)

  • index: Lista de índices, default None (se refere a todos os índices disponíveis).
    • Índices dos quais se quer consultar os símbolos de membros.

Retorno:
Retorna o dicionário com as listas de símbolos ou dicionário de símbolos para pesos (se disponíveis) dos membros dos índices.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        symbols = data.get.symbols.index_members(index='IBOV')



get instruments

Agrupa os métodos utilizados para recuperar instrumentos.


get instruments price_bar()

Descrição:
Método usado para recuperar instrumentos de barras de preços.

Chamada:
data.get.instruments.price_bar(symbols)

  • symbols: Lista de strings, default None (se refere a todos os instrumentos ativos).
    • Símbolos dos instrumentos que se deseja recuperar.

Retorno:
Retorna um dicionário de referências (símbolos) para os instrumentos.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        instruments = data.get.instruments.price_bar(['PETR4', 'TSLA'])

get instruments equity()

Descrição:
Método usado para recuperar instrumentos de equities.

Chamada:
data.get.instruments.equity(symbols)

  • symbols: Lista de strings, default None (se refere a todos os instrumentos ativos).
    • Símbolos dos instrumentos que se deseja recuperar.

Retorno:
Retorna um dicionário de referências (símbolos) para os instrumentos.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        instruments = data.get.instruments.equity(['PETR4', 'TSLA'])

get instruments fx()

Descrição:
Método usado para recuperar instrumentos de FX.

Chamada:
data.get.instruments.fx(symbols)

  • symbols: Lista de strings, default None (se refere a todos os instrumentos ativos).
    • Símbolos dos instrumentos que se deseja recuperar.

Retorno:
Retorna um dicionário de referências (símbolos) para os instrumentos.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        instruments = data.get.instruments.fx('USDBRL')

get instruments tradable()

Descrição:
Método usado para recuperar instrumentos negociáveis.

Chamada:
data.get.instruments.tradable(symbols)

  • symbols: Lista de strings, default None (se refere a todos os instrumentos ativos).
    • Símbolos dos instrumentos que se deseja recuperar.

Retorno:
Retorna um dicionário de referências (símbolos) para os instrumentos.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        instruments = data.get.instruments.tradable(['BPAC11', 'FOX'])

get instruments index()

Descrição:
Método usado para recuperar instrumentos de índices.

Chamada:
data.get.instruments.index(symbols)

  • symbols: Lista de strings, default None (se refere a todos os instrumentos ativos).
    • Símbolos dos instrumentos que se deseja recuperar.

Retorno:
Retorna um dicionário de referências (símbolos) para os instrumentos.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        instruments = data.get.instruments.index(['IBOV', 'SPX'])

get instruments macro()

Descrição:
Método usado para recuperar instrumentos de variáveis macroeconômicas.

Chamada:
data.get.instruments.macro(symbols)

  • symbols: Lista de strings, default None (se refere a todos os instrumentos ativos).
    • Símbolos dos instrumentos que se deseja recuperar.

Retorno:
Retorna um dicionário de referências (símbolos) para os instrumentos.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        instruments = data.get.instruments.macro(['IBOV', 'SPX'])

get instruments exchange()

Descrição:
Método usado para recuperar instrumentos de bolsas.

Chamada:
data.get.instruments.exchange(symbols)

  • symbols: Lista de strings, default None (se refere a todos os instrumentos ativos).
    • Símbolos dos instrumentos que se deseja recuperar.

Retorno:
Retorna um dicionário de referências (símbolos) para os instrumentos.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        instruments = data.get.instruments.exchange(['IBOV', 'SPX'])

get instruments currency()

Descrição:
Método usado para recuperar instrumentos de moedas.

Chamada:
data.get.instruments.currency(symbols)

  • symbols: Lista de strings, default None (se refere a todos os instrumentos ativos).
    • Símbolos dos instrumentos que se deseja recuperar.

Retorno:
Retorna um dicionário de referências (símbolos) para os instrumentos.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        instruments = data.get.instruments.currency(['IBOV', 'SPX'])

get instruments country()

Descrição:
Método usado para recuperar instrumentos de países.

Chamada:
data.get.instruments.country(symbols)

  • symbols: Lista de strings, default None (se refere a todos os instrumentos ativos).
    • Símbolos dos instrumentos que se deseja recuperar.

Retorno:
Retorna um dicionário de referências (símbolos) para os instrumentos.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        instruments = data.get.instruments.country(['IBOV', 'SPX'])



get latest

Agrupa os métodos utilizados para recuperar valores ou objetos mais recentes de instrumentos.


get latest price_bar_values()

Descrição:
Método usado para recuperar os valores mais recentes de instrumentos de barras de preços.

Chamada:
data.get.latest.price_bar_values(instruments, base_currency)

  • instruments: Lista de instrumentos de barras de preços, default None (refere-se a todos os instrumentos de barras de preços assinados).
    • Especifica quais instrumentos terão seus valores buscados.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.

Retorno:
Retorna um dicionário de instrumentos para valores.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        PETR4_price = data.get.latest.price_bar_values('PETR4')

get latest price_bar_objects()

Descrição:
Método usado para recuperar os objetos de dados mais recentes de instrumentos de barras de preços.

Chamada:
data.get.latest.price_bar_objects(instruments)

  • instruments: Lista de instrumentos de barras de preços, default None (refere-se a todos os instrumentos de barras de preços assinados).
    • Especifica quais instrumentos terão seus objetos de dados buscados.

Retorno:
Retorna um dicionário de instrumentos para objetos de dados.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        PETR4_bar = data.get.latest.price_bar_objects('PETR4')

get latest macro_values()

Descrição:
Método usado para recuperar os valores mais recentes de variáveis macroeconômicas.

Chamada:
data.get.latest.macro_values(instruments)

Retorno:
Retorna um dicionário de instrumentos para valores.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        cdi_value = data.get.latest.macro_values('CDI')

get latest macro_objects()

Descrição:
Método usado para recuperar os objetos de dados mais recentes de variáveis macroeconômicas.

Chamada:
data.get.latest.macro_objects(instruments)

  • instruments: Lista de instrumentos de barras de preços, default None (refere-se a todos os instrumentos de barras de preços assinados).
    • Especifica quais instrumentos terão seus objetos de dados buscados.

Retorno:
Retorna um dicionário de instrumentos para objetos de dados.

Exemplo:

1
2
3
4
5
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        cdi_update = data.get.latest.macro_objects('CDI')



get lookback

Agrupa os métodos utilizados para recuperar valores das janelas de lookback de instrumentos.


get lookback price_bar()

Descrição:
Método usado para recuperar valores das janelas de lookback de instrumentos de barras de preços.

Chamada:
data.get.lookback.price_bar(instruments, fields, dataframe, data_object, frequency, intersect)

  • instruments: Lista de instrumentos de barras de preços, default None (refere-se a todos os instrumentos de barras de preços assinados).
    • Especifica quais instrumentos terão seus valores buscados.
  • fields: lista de strings, default None (retorna todos os campos disponíveis);
    • Define que campos de dados serão recuperados da janela de lookback;
    • Os campos disponíveis constam na propriedade data_fields do instrumento;
  • dataframe: bool, default False;
    • Se True o retorno será gerado em formato de pandas.DataFrame;
  • data_object: bool, default False;
    • Se True, o método irá retornar objetos de dados (os mesmos que são recebidos a cada evento);
  • frequency: Número ou string temporal, default None (assume-se a frequência base da estratégia);
    • Especifica a frequência dos dados requisitados;
    • Se numérico, será assumida a unidade de segundos;
  • intersect: bool, default False.
    • Se True, as extensões temporais de todas as janelas de lookback serão interseccionadas.

Retorno:
Retorna um dicionário de instrumentos para valores requeridos.

Exemplo:

1
2
3
4
5
6
7
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        data.subscribe.price_bar('ABEV3', lookback_length=10)

        lookback = data.get.lookback.price_bar(instruments='ABEV3')

get lookback macro()

Descrição:
Método usado para recuperar valores das janelas de lookback de variáveis macroeconômicas.

Chamada:
data.get.lookback.macro(instruments, fields, dataframe, data_object, intersect)

  • instruments: Lista de instrumentos de barras de preços, default None (refere-se a todos os instrumentos de barras de preços assinados).
    • Especifica quais instrumentos terão seus valores buscados.
  • fields: lista de strings, default None (retorna todos os campos disponíveis);
    • Define que campos de dados serão recuperados da janela de lookback;
    • Os campos disponíveis constam na propriedade data_fields do instrumento;
  • dataframe: bool, default False;
    • Se True o retorno será gerado em formato de pandas.DataFrame;
  • data_object: bool, default False;
    • Se True, o método irá retornar objetos de dados (os mesmos que são recebidos a cada evento);
  • intersect: bool, default False.
    • Se True, as extensões temporais de todas as janelas de lookback serão interseccionadas.

Retorno:
Retorna um dicionário de instrumentos para valores requeridos.

Exemplo:

1
2
3
4
5
6
7
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        data.subscribe.macro_update('CDI', lookback_length=10)

        lookback = data.get.lookback.macro(instruments='CDI')



get hist

Agrupa os métodos utilizados para recuperar valores históricos de instrumentos.


get hist price_bar()

Descrição:
Método usado para recuperar dados históricos de instrumentos de barras de preços.

Chamada:
data.get.hist.price_bar(instruments, length, frequency, adjusted, concat, dataframe, remove_outliers)

  • instruments: Lista de instrumentos de barras de preços, default None (refere-se a todos os instrumentos de barras de preços assinados).
    • Especifica quais instrumentos terão seus valores buscados.
  • length: Número inteiro, string temporal ou datetime.timedelta;
    • Indica o tamanho da série histórica desejada;
    • Se for um número inteiro, serão buscados os últimos length objetos de dados na base; Se for uma string temporal ou datetime.timedelta, serão buscados dados na janela histórica indicada;
  • frequency: Número ou string temporal, default None (assume-se a frequência base da estratégia);
    • Especifica a frequência dos dados requisitados;
    • Se numérico, será assumida a unidade de segundos;
  • adjusted: bool, default None (refere-se à opção de ajuste feita na assinatura ou True se o instrumento não tiver sido assinado);
    • Especifica se os dados requisitados devem ser ajustados para compensar eventos corporativos (True) ou não (False);
  • concat: bool, default True;
    • Se True, os dados serão concatenados. Se False os dados serão retornados em formato de dicionário;
  • dataframe: bool, default False;
    • Se True o retorno será gerado em formato de pandas.DataFrame;
  • remove_outliers: bool, default True;
    • Se True, os dados considerados outliers pela plataforma serão excluídos do resultado. Se False, elas serão incluídos;

Retorno:
Retorna um dicionário de instrumentos para valores requeridos (se concat=False).

Exemplo:

1
2
3
4
5
6
from dorothy import StrategyBase, data
from datetime import timedelta

class Strategy(StrategyBase):
    def on_init(self, settings):
        hist = data.get.hist.price_bar(instruments='ABEV3', length='10D')

get hist macro_update()

Descrição:
Método usado para recuperar dados históricos de variáveis macroeconômicas.

Chamada:
data.get.hist.macro_update(instruments, length, concat, dataframe)

  • instruments: Lista de instrumentos de barras de preços, default None (refere-se a todos os instrumentos de barras de preços assinados).
    • Especifica quais instrumentos terão seus valores buscados.
  • length: Número inteiro, string temporal ou datetime.timedelta;
    • Indica o tamanho da série histórica desejada;
    • Se for um número inteiro, serão buscados os últimos length objetos de dados na base; Se for uma string temporal ou datetime.timedelta, serão buscados dados na janela histórica indicada;
  • concat: bool, default True;
    • Se True, os dados serão concatenados. Se False os dados serão retornados em formato de dicionário;
  • dataframe: bool, default False;
    • Se True o retorno será gerado em formato de pandas.DataFrame;

Retorno:
Retorna um dicionário de instrumentos para valores requeridos (se concat=False).

Exemplo:

1
2
3
4
5
6
from dorothy import StrategyBase, data
from datetime import timedelta

class Strategy(StrategyBase):
    def on_init(self, settings):
        hist = data.get.hist.macro_update(instruments='CDI', length='10D')



get subscribed

Agrupa os métodos utilizados para consultar os instrumentos assinados.


get subscribed price_bar

Descrição:
Método usado para consultar instrumentos de barras de preços que foram assinados.

Chamada:
data.get.subscribed.price_bar

Retorno:
Retorna a lista de instrumentos assinados.

Exemplo:

1
2
3
4
5
6
7
8
from dorothy import StrategyBase, data
from datetime import timedelta

class Strategy(StrategyBase):
    def on_init(self, settings):
        data.subscribe.price_bar('BOVA11')

        subscribed = data.get.subscribed.price_bar

get subscribed equity

Descrição:
Método usado para consultar instrumentos de equities que foram assinados.

Chamada:
data.get.subscribed.equity

Retorno:
Retorna a lista de instrumentos assinados.

Exemplo:

1
2
3
4
5
6
7
8
from dorothy import StrategyBase, data
from datetime import timedelta

class Strategy(StrategyBase):
    def on_init(self, settings):
        data.subscribe.equity('BBDC3')

        subscribed = data.get.subscribed.equity

get subscribed fx

Descrição:
Método usado para consultar instrumentos de FX que foram assinados.

Chamada:
data.get.subscribed.fx

Retorno:
Retorna a lista de instrumentos assinados.

Exemplo:

1
2
3
4
5
6
7
8
from dorothy import StrategyBase, data
from datetime import timedelta

class Strategy(StrategyBase):
    def on_init(self, settings):
        data.subscribe.fx('USDBRL')

        subscribed = data.get.subscribed.fx

get subscribed tradable

Descrição:
Método usado para consultar instrumentos negociáveis que foram assinados.

Chamada:
data.get.subscribed.tradable

Retorno:
Retorna a lista de instrumentos assinados.

Exemplo:

1
2
3
4
5
6
7
8
from dorothy import StrategyBase, data
from datetime import timedelta

class Strategy(StrategyBase):
    def on_init(self, settings):
        data.subscribe.tradable('ITSA4')

        subscribed = data.get.subscribed.tradable

get subscribed index

Descrição:
Método usado para consultar índices que foram assinados.

Chamada:
data.get.subscribed.index

Retorno:
Retorna a lista de instrumentos assinados.

Exemplo:

1
2
3
4
5
6
7
8
from dorothy import StrategyBase, data
from datetime import timedelta

class Strategy(StrategyBase):
    def on_init(self, settings):
        data.subscribe.index('IBOV')

        subscribed = data.get.subscribed.index

get subscribed macro

Descrição:
Método usado para consultar variáveis macroeconômicas que foram assinados.

Chamada:
data.get.subscribed.macro

Retorno:
Retorna a lista de instrumentos assinados.

Exemplo:

1
2
3
4
5
6
7
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        data.subscribe.macro_update('GDP')

        subscribed = data.get.subscribed.macro

get subscribed exchange

Descrição:
Método usado para consultar bolsas que possuem instrumentos assinados.

Chamada:
data.get.subscribed.exchange

Retorno:
Retorna a lista de instrumentos assinados.

Exemplo:

1
2
3
4
5
6
7
from dorothy import StrategyBase, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        data.subscribe.price_bar('EMBR3')

        subscribed = data.get.subscribed.exchange



Time


current_time

Descrição:
Método usado para recuperar o horário atual no tempo da estratégia.

Chamada:
time.current_time

Retorno:
Retorna um objeto datetime.datetime com o horário atual no tempo da estratégia.

Exemplo:

1
2
3
4
5
6
from dorothy import StrategyBase, time

class Strategy(StrategyBase):
    def on_init(self, settings):
        # Mandando mensagem com horário atual para o log da estratégia
        print(f'{time.current_time}: começando estratégia')

current_date

Descrição:
Método usado para recuperar a data atual no tempo da estratégia.

Chamada:
time.current_date

Retorno:
Retorna um objeto datetime.datetime com a data atual (horas, segundos e minutos zerados) no tempo da estratégia.

Exemplo:

1
2
3
4
5
6
from dorothy import StrategyBase, time

class Strategy(StrategyBase):
    def on_init(self, settings):
        # Recuperando data atual no tempo da estratégia
        current_date = time.current_date

market_open_time()

Descrição:
Método usado para recuperar os horários de abertura de uma lista de bolsas em determinada data.

Chamada:
time.market_open_time(exchanges, date)

  • exchanges: Default None (refere-se a todas as bolsas ativas).
    • Lista de bolsas.
  • date: Objeto datetime.datetime, default None (refere-se ao dia atual no tempo da estratégia).
    • Data na qual se deve buscar o horário de abertura.

Retorno:
Retorna um dicionário de horários de abertura identificados pelas respectivas bolsas.

Exemplo:

1
2
3
4
5
6
7
from dorothy import StrategyBase, time, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        # Por default, os dados são do dia atual.
        self.bolsas_assinadas = data.get.exchanges()
        self.open_times = time.market_open_time(exchanges=self.bolsas_assinadas)

market_close_time()

Descrição:
Método usado para recuperar os horários de fechamento de uma lista de bolsas.

Chamada:
time.market_close_time(exchanges, date)

  • exchanges: Default None (refere-se a todas as bolsas ativas).
    • Lista de bolsas.
  • date: Objeto datetime.datetime, default None (refere-se ao dia atual no tempo da estratégia).
    • Data na qual se deve buscar o horário de fechamento.

Retorno:
Retorna um dicionário de horários de fechamento identificados pelas respectivas bolsas.

Exemplo:

1
2
3
4
5
6
7
from dorothy import StrategyBase, time, data

class Strategy(StrategyBase):
    def on_init(self, settings):
        # Por default, os dados são do dia atual.
        self.bolsas_assinadas = data.get.exchanges()
        self.close_times = time.market_close_time(exchanges=self.bolsas_assinadas)

schedule_function()

Descrição:
Método usado para agendar uma função com seus possíveis parâmetros.

Chamada:
time.schedule_function(function, args, start_on, step, offset, repeat, repeats_till_day_close, repeats_till_cancel)

  • function:
    • Método (da plataforma ou criado pelo usuário) que será agendado.
  • args: Lista ou dicionário, default None (chamada sem parâmetros).
    • Parâmetros requisitados pelo método que será agendado. Se for uma lista, os valores serão distribuídos na chamada da função sequencialmente. Se for um dicionário, os inputs da função serão chamados por seus nomes, que devem estar presentes no dicionário.
  • start_on: datetime.datetime ou string, default None (começa imediatamente).
    • Se for um objeto datetime.datetime, define o início da execução do método agendado.
    • Como string, deve especificar um método e, opcionalmente, um argumento, separados por um ponto (e.g.: 'market_open', 'week.3'). A cada step que entre um novo dia, o start_on será reavalido. Se o step não for definido, a cada execução o próximo horário especificado pelo método e argumento será agendado. Os seguintes métodos são aceitos:
      • 'market_open': especifica o horário de abertura do mercado. Aceita como argumento o símbolo de uma bolsa específica (e.g.: 'market_open.B3', 'market_open.NYSE'). Sem argumentos, será considerado o mesmo horário do evento de abertura de mercado.
      • 'market_close': especifica o horário de fechamento do mercado. Aceita como argumento o símbolo de uma bolsa específica (e.g.: 'market_close.B3', 'market_close.NYSE'). Sem argumentos, será considerado o mesmo horário do evento de fechamento de mercado.
      • 'week': especifica o começo da semana. Aceita uma quantidade de semanas (e.g.: 'week.3', 'week.1'). Sem argumentos, será considerada uma (1) semana.
      • 'month': especifica o começo do mês. Aceita uma quantidade de meses (e.g.: 'week.3', 'week.1'). Sem argumentos, será considerado um (1) mês.
      • 'year': especifica o começo do ano. Aceita uma quantidade de anos (e.g.: 'week.3', 'week.1'). Sem argumentos, será considerado um (1) ano.
  • step: datetime.timedelta, default None.
    • Passo de tempo entre repetições do método agendado. Se start_on for uma string, a cada vez que o passo entrar em um novo dia a próxima execução ocorrerá no momento especificado pela string.
  • offset: datetime.timedelta, default None.
    • Tempo de espera ou atraso adicional para as execução agendadas. Se start_on especificar o horário de encerramento da B3, por exemplo (start_on = 'market_close.B3') e o offset for configurado para offset = -timedelta(minutes=15), as execuções ocorrerão 15 minutos antes do fechamento do mercado.
  • repeat: Default 1.
    • Número de vezes que o método agendado irá se repetir.
  • repeats_till_day_close: bool, default False.
    • Booleano que define se o método irá se repetir até o fechamento do mercado (day_close).
  • repeats_till_cancel: bool, default False.
    • Booleano que define se o método ira se repetir até que o agendamento seja cancelado ou a execução da estrátegia seja finalizada.

Retorno:
Retorna o ID do agendamento criado.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from dorothy import StrategyBase, time, data, order
from datetime import timedelta, datetime

class Strategy(StrategyBase):

    def on_init(self, settings):

        ...

        # Agendando execução da minha_funcao para todos os dias às 12h
        self.scheduled_function_id_1 = time.schedule_function(
            function=self.minha_funcao,
            start_on=time.current_date + timedelta(hours=12),
            step=timedelta(days=1),
            repeats_till_cancel=True,
        )
    ...

    def on_day_open(self):

        # Agenda uma função de compra a mercado de R$10,000.00 no ativo PETR4 10 minutos antes do fechamento do mercado.
        self.scheduled_function_id_2 = time.schedule_function(
            function=order.send.market,
            args={
                'instrument':'PETR4',
                'side':order.fields.side.BUY,
                'amount':10000,
            },
            start_on='market_close',
            offset=-timedelta(minutes=10),
        )

    # Esta função será executada às 12h de cada dia
    def minha_funcao(self):
        print(time.current_time)

destroy_schedules()

Descrição:
Método usado para apagar agendamentos especificados pela lista de IDs.

Chamada:
time.destroy_schedules(ids)

  • ids: Default None (refere-se a todos os IDs ativos).
    • Lista de IDs de agendamentos a serem apagados.

Retorno:
Retorna um dicionário de booleanos confirmando o cancelamento dos agendamentos identificados pelos seus IDs.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from dorothy import StrategyBase, time

class Strategy(StrategyBase):

    ...

    def on_day_close(self):

        # Apaga os agendamentos das ordens de ID 2 e 3.
        self.schedules = time.destroy_schedules([2, 3])

        # Apaga todos os agendamentos.
        self.schedules = time.destroy_schedules()

Order

Existem múltiplos tipos de ordens na plataforma. Elas podem ser enviadas a partir do submódulo send de order, que irá retornar objetos representativos da ordem. Esses objetos possuem diversos campos para acompanhamento das ordens, assim como o método cancel(), que pode ser utilizado para cancelar a ordem diretamente a partir do objeto. As atualizações das ordens serão recebidas pelo método receptor dedicado da estratégia.

O módulo order conta com os seguintes atributos auxiliares:

Os diferentes tipos de ordens podem ser enviados a partir dos seguintes métodos de order.send:

As ordens respeitarão as lotes de execução (lot_size) informados nos instrumentos. A plataforma não simula ou fornece dados de mercado fracionário.


fields

Especifica os possíveis valores que podem ser utilizados para implementar as ordens da estratégia. Eles são referentes ao tipo de ordem (por exemplo, ordem de compra), ao status da ordem (por exemplo, rejeitada), à validade da ordem (por exemplo, válida pelo dia atual) e à razão pela qual a ordem foi cancelada ou rejeitada - quando isso ocorre.

fields.side

  • SHORT_SELL: Ordem com operação de short, ou seja, de maneira com que os instrumentos fiquem vendidos.
  • SELL: Ordem simples de venda.
  • BUY: Ordem simples de compra.
  • BUY_COVER: Ordem com operação de compra coberta.

fields.status

  • PENDING_SUBMIT: Estado da ordem anterior ao seu envio para execução ou rejeição.
  • SUBMITTED: Estado da ordem após seu envio para execução e anterior à quaisquer execuções.
  • PARTIAL_FILLED: Ocorreu uma execução parcial da ordem e ainda restam execuções a serem feitas.
  • FILLED: A ordem foi totalmente executada, tornando-se inativa.
  • PENDING_CANCEL: O pedido de cancelamento da ordem foi enviado mas a confirmação de cancelamento ainda não foi recebida.
  • CANCELLED: A ordem foi cancelada antes de ser totalmente executada, tornando-se inativa.
  • REJECTED: A ordem não foi enviada para execução, pois violou algum critério de envio (e.g., possuía tamanho nulo, tentou comprar um ativo que não havia sido assinado ou que ainda não tinha preço) e tornou-se inativa.

fields.time_in_force

  • GOOD_FOR_A_DAY: Validade até o fim do dia - quando o dia termina, a ordem é cancelada.
  • GOOD_TILL_CANCEL: Validade até o cancelamento da ordem, seja ele de forma deliberada ou por alguma das razões em cancel_reject_reason.
  • IMMEDIATE_OR_CANCEL: Validade imediata - a ordem é cancelada se não for possível executá-la naquele momento.
  • GOOD_TILL_DATE: Validade até uma data específica - quando essa data chega, se a ordem ainda estiver ativa, ela é cancelada.

fields.cancel_reject_reason

  • INSTRUMENT_NOT_SUBSCRIBED: Instrumento da ordem não foi assinado, causando sua rejeição.
  • INSUFFICIENT_SIZE: A quantidade de ativos correspondente à ordem está abaixo do mínimo executável, causando sua rejeição.
  • ABOVE_MAX_POSITION: O volume financeiro máximo especificado foi atingido, fazendo com que a ordem fosse rejeitada.
  • INSUFFICIENT_CAPITAL: Não há capital suficiente para executar a ordem, por isso ela foi rejeitada.
  • NO_PRICE_AVAILABLE: Não há um preço disponível para o instrumento da ordem naquele momento e, portanto, a ordem deve ser rejeitada.
  • MAX_NUM_ORDERS: O número máximo de ordens ativas (definido pelo usuário nos settings foi atingido, fazendo com que a ordem fosse rejeitada.
  • GOOD_FOR_A_DAY: Quando o dia acabou, a ordem com essa validade foi cancelada.
  • IMMEDIATE_OR_CANCEL: A ordem de validade IMMEDIATE_OR_CANCEL (IOC) não foi completamente executada imediatamente, então foi cancelada por conta dessa validade específica.
  • GOOD_TILL_DATE: Quando o dia e horário especificados na ordem com essa validade chegaram, a ordem foi cancelada.
  • STRATEGY_REQUEST: Cancelamento por pedido da estratégia.
  • CANCEL_ALL_TRIGGERED: Foi executado o comando de cancelar todas as ordens.
  • PARENT_ORDER_CANCELLED: A ordem na verdade faz parte de uma ordem principal. Se a principal for cancelada, consequentemente essa ordem também será.

has_active_orders()

Descrição:
Método usado para verificar se existem ordens ativas dos instrumentos especificados.

Chamada:
order.has_active_orders(instruments, buy, sell, any_active, all_active)

  • instruments: Lista de instrumentos negociáveis, default None (refere-se a todos os instrumentos negociáveis assinados).
    • Especifica quais instrumentos terão suas ordens contabilizadas.
  • buy: bool, default False:
    • Se True, apenas as ordens de compra de ativos serão consideradas.
  • sell: bool, default False:
    • Se True, apenas as ordens de compra de ativos serão consideradas.
  • any_active: bool, default True:
    • Se True, em vez de um dicionário, a resposta virá como um bool simples, sendo True se qualquer um dos instrumentos especificados for localizado e False se nenhum for.
  • all_active: bool, default False:
    • Se True, em vez de um dicionário, a resposta virá como um booleano simples, sendo True se todos os instrumentos especificados forem localizados e False se qualquer um não for.

Retorno:
Retorna um valor booleano ou um dicionário de bools indexados pelo símbolos especificados.

Exemplo:

1
2
3
4
5
6
7
8
9
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        # Verifica se existem ordens ativas para os ativos AZUL4 e PETR3.
        check_orders = order.has_active_orders(['AZUL4', 'PETR3'])

num_active_orders()

Descrição:
Método usado para verificar quantas ordens ativas existem para os instrumentos especificados.

Chamada:
order.num_active_orders(instruments, buy, sell, total)

  • instruments: Lista de instrumentos negociáveis, default None (refere-se a todos os instrumentos negociáveis assinados).
    • Especifica quais instrumentos terão suas ordens contabilizadas.
  • buy: bool, default False:
    • Se True, apenas as ordens de compra de ativos serão consideradas.
  • sell: bool, default False:
    • Se True, apenas as ordens de compra de ativos serão consideradas.
  • total: bool, default False.
    • Se verdadeiro, soma os números de ordens ativas de todos os instrumentos especificados. Se falso, os números de ordens ativas são segregados por instrumento e disponibilizados em um dicionário.

Retorno:
Retorna a quantidade de ordens ativas ou um dicionário de números de ordens segregadas por ativo.

Exemplo:

1
2
3
4
5
6
7
8
9
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        # Recupera o número de ordens ativas para os ativos AZUL4 e PETR3, segregado por ativo.
        self.num_active_orders = order.num_active_orders(['AZUL4', 'PETR3'], False)

active_orders()

Descrição:
Método usado para recuperar os objetos de ordens ativas.

Chamada:
order.active_orders(instruments, buy, sell)

  • instruments: Lista de instrumentos negociáveis, default None (refere-se a todos os instrumentos negociáveis assinados).
    • Especifica quais instrumentos terão suas ordens recuperadas.
  • buy: bool, default False:
    • Se True, apenas as ordens de compra de ativos serão consideradas.
  • sell: bool, default False:
    • Se True, apenas as ordens de compra de ativos serão consideradas.

Retorno:
Retorna uma lista com as ordens ativas dos ativos especificados.

Exemplo:

1
2
3
4
5
6
7
8
9
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        # Recupera todas as ordens ativas para os ativos AZUL4 e PETR3.
        self.active_orders = order.active_orders(['AZUL4', 'PETR3'])

cancel()

Descrição:
Método usado para cancelar ordens especificadas.

Chamada:
order.cancel(orders, instruments)

  • orders: lista de números inteiros ou objetos de ordens, default None (refere-se a todas as ordens ativas se instruments não tiver sido especificado).
    • Lista de IDs ou objetos das ordens que devem ser canceladas.
  • instruments: Lista de instrumentos negociáveis, default None (refere-se a todos os instrumentos negociáveis assinados se orders não tiver side especificado).
    • Especifica quais instrumentos terão suas ordens canceladas.

Exemplo:

1
2
3
4
5
6
7
8
9
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        # Cancela a ordem com ID e todas as ordens nos instrumentos PETR4 e ABEV3
        order.cancel(orders=2, instruments=['PETR4', 'ABEV3'])



send.market()

Descrição:
Método usado para enviar uma ordem a mercado. Ordens a mercado são executadas sem restrições no primeiro preço disponível. Cuidado especial deve ser tomado ao emitir ordens a mercado especificadas por lote (em vez de por financeiro), pois flutuações no preço podem levar a gastos excessivos.

Chamada:
order.send.market(instrument, side, size, amount, time_in_force, expiration_date, ooreason, distributed, target)

  • instruments: Lista ou dicionário de instrumentos negociáveis para pesos na basket
    • Define o(s) ativo(s) que será comprado ou vendido pela ordem. Se definidos no formato de dicionário, os valores serão considerados pesos que multiplicam o amount/size de cada ativo (se distributed=True, os pesos serão normalizados). Se um peso for negativo, ele reverterá o side daquele ativo. Se for enviada uma lista de instrumentos, será considerado peso unitário para cada um.
  • distributed: bool, default True.
    • Se True, os pesos definidos em instruments serão normalizados (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$250.000,00 em PETR3 e R$750.000,00 em BPAC11). Se False, os pesos definidos serão tomados sem normalização (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$1.000.000,00 em PETR3 e R$3.000.000,00 em BPAC11).
  • side: string, default None (será inferido como 'BUY' ou 'SELL' pelo sinal de amount ou size)
    • Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL').
  • size: número, default None (amount deve ser especificado)
    • Tamanho do lote (quantidade de ativos) da ordem.
  • amount: número, default None (size deve ser especificado)
    • Volume financeiro da ordem.
  • time_in_force: string, default 'GTC'.
    • Validade da ordem ['GFD' (GOOD_FOR_A_DAY), 'GTC' (GOOD_TILL_CANCEL), 'IOC' (IMMEDIATE_OR_CANCEL) ou 'GTD' (GOOD_TILL_DATE)].
  • expiration_date: datetime.datetime, default None.
    • Data de expiração da ordem. Válido apenas para time_in_force='GTD'.
  • ooreason: string, default None.
    • Razão pela qual se enviou a ordem (apenas para controle, não surte efeito na execução).
  • target: bool, default False.
    • Se True, a ordem será gerada de forma que, após sua execução, o amount/size definido seja atingido. Por exemplo, uma ordem com target=True e size nulo será convertida em uma ordem de fechamento de todas as posições possuídas. Atenção: As ordens com execuções pendentes não serão levadas em conta. Considere cancelar as ordens pendentes antes do envio da ordem target.

Retorno:
Retorna o objeto da ordem criada, contendo os seguintes campos:

  • id: ID da ordem;
  • instrument: Instrumento que a ordem opera;
  • type: Tipo da ordem (retorna 'Market');
  • submit_time: Horário de criação da ordem;
  • ooreason: Campo ooreason preenchido no envio da ordem;
  • side: Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL');
  • buy: True se a ordem tem side 'BUY' ou 'BUY_COVER', False em caso contrário;
  • sell: True se a ordem tem side 'SELL' ou 'SHORT_SELL', False em caso contrário;
  • by_amount: True se a ordem foi definida por amount, False em caso contrário;
  • by_size: True se a ordem foi definida por size, False em caso contrário;
  • amount: amount definido no envio da ordem;
  • size: size definido no envio da ordem;
  • executed_amount: volume financeiro que a ordem já executou;
  • executed_size: quantidade de ações que a ordem já executou;
  • remaining_amount: volume financeiro pendentes na ordem;
  • remaining_size: volume financeiro pendentes na ordem;
  • average_executed_price: preço ponderado por volume de todas as execuções da ordem;
  • commission: comissão total já paga pela ordem;
  • time_in_force: time_in_force definido no envio da ordem;
  • expiration_date: time_in_force definido no envio da ordem;
  • status: estado atual da ordem;
  • pending_submit: True se o status da ordem é 'PENDING_SUBMIT', False em caso contrário;
  • submitted: True se o status da ordem é 'SUBMITTED', False em caso contrário;
  • finalized: True se o status da ordem é 'FILLED', 'CANCELLED' ou 'REJECTED', False em caso contrário;
  • partial_filled: True se o status da ordem é 'PARTIAL_FILLED', False em caso contrário;
  • filled: True se o status da ordem é 'FILLED', False em caso contrário;
  • rejected: True se o status da ordem é 'REJECTED', False em caso contrário;
  • pending_cancel: True se o status da ordem é 'PENDING_CANCEL', False em caso contrário;
  • cancelled: True se o status da ordem é 'CANCELLED', False em caso contrário;
  • cancel_reject_reason: string com o motivo do cancelamento ou rejeição se a ordem tiver sido cancelada ou rejeitada, None em caso contrário;
  • cancel: método para cancelar a ordem diretamente pelo objeto (order.cancel());
  • is_market: True se a ordem for do tipo 'Market', False em caso contrário (retorna True);
  • is_limit: True se a ordem for do tipo 'Limit', False em caso contrário (retorna False);
  • is_stop: True se a ordem for do tipo 'Stop', False em caso contrário (retorna False);
  • is_stop_limit: True se a ordem for do tipo 'StopLimit', False em caso contrário (retorna False);
  • is_twap: True se a ordem for do tipo 'TWAP', False em caso contrário (retorna False);
  • is_vwap: True se a ordem for do tipo 'VWAP', False em caso contrário (retorna False);
  • is_trailing_stop: True se a ordem for do tipo 'TrailingStop', False em caso contrário (retorna False);
  • is_bracket: True se a ordem for do tipo 'Bracket', False em caso contrário (retorna False);

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    def on_init(self):
        self.instr_PETR4 = data.subscribe.price_bar('PETR4')

    ...

    def on_day_open(self):
        # Envia uma ordem de compra a mercado de R$100,000.00 no ativo PETR4 com validade até o fechamento do mercado no dia.
        market_order = order.send.market(
            instrument=self.instr_PETR4,
            side=order.fields.side.BUY,
            amount=100000,
            time_in_force=order.fields.time_in_force.GOOD_FOR_A_DAY,
        )

        print(market_order)

    def on_order_status(self, exec_info):
        print(exec_info)

send.limit()

Descrição:
Método usado para enviar uma ordem com valor limitado; isto é, define-se um preço limite até o qual a ordem pode executar (se a ordem for de compra, o limite é o preço máximo aceitável, se for de venda, o limite é o preço mínimo aceitável).

Chamada:
order.send.limit(instrument, side, amount, size, limit, time_in_force, expiration_date, ooreason, distributed, target)

  • instruments: Lista ou dicionário de instrumentos negociáveis para pesos na basket
    • Define o(s) ativo(s) que será comprado ou vendido pela ordem. Se definidos no formato de dicionário, os valores serão considerados pesos que multiplicam o amount/size de cada ativo (se distributed=True, os pesos serão normalizados). Se um peso for negativo, ele reverterá o side daquele ativo. Se for enviada uma lista de instrumentos, será considerado peso unitário para cada um.
  • distributed: bool, default True.
    • Se True, os pesos definidos em instruments serão normalizados (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$250.000,00 em PETR3 e R$750.000,00 em BPAC11). Se False, os pesos definidos serão tomados sem normalização (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$1.000.000,00 em PETR3 e R$3.000.000,00 em BPAC11).
  • side: string, default None (será inferido como 'BUY' ou 'SELL' pelo sinal de amount ou size)
    • Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL').
  • size: número, default None (amount deve ser especificado)
    • Tamanho do lote (quantidade de ativos) da ordem.
  • amount: número, default None (size deve ser especificado)
    • Volume financeiro da ordem.
  • limit: Número ou dicionário de instrumentos para os limites individuais de cada ativo
    • Limite de preço em que a ordem pode ser executada. Se mais de um ativo for definido em instrument e limit for um número, este número será tomado como preço limite de todos os ativos. Se limit for um dicionário especificando os limites específicos de cada ativo, deverá definir todos os ativos que constam em instruments.
  • time_in_force: string, default 'GTC'.
    • Validade da ordem ['GFD' (GOOD_FOR_A_DAY), 'GTC' (GOOD_TILL_CANCEL), 'IOC' (IMMEDIATE_OR_CANCEL) ou 'GTD' (GOOD_TILL_DATE)].
  • expiration_date: datetime.datetime, default None.
    • Data de expiração da ordem. Válido apenas para time_in_force='GTD'.
  • ooreason: string, default None.
    • Razão pela qual se enviou a ordem (apenas para controle, não surte efeito na execução).
  • target: bool, default False.
    • Se True, a ordem será gerada de forma que, após sua execução, o amount/size definido seja atingido. Por exemplo, uma ordem com target=True e size nulo será convertida em uma ordem de fechamento de todas as posições possuídas. Atenção: As ordens com execuções pendentes não serão levadas em conta. Considere cancelar as ordens pendentes antes do envio da ordem target.

Retorno:
Retorna o objeto da ordem criada, contendo os seguintes campos:

  • id: ID da ordem;
  • instrument: Instrumento que a ordem opera;
  • type: Tipo da ordem (retorna 'Limit');
  • submit_time: Horário de criação da ordem;
  • ooreason: Campo ooreason preenchido no envio da ordem;
  • side: Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL');
  • buy: True se a ordem tem side 'BUY' ou 'BUY_COVER', False em caso contrário;
  • sell: True se a ordem tem side 'SELL' ou 'SHORT_SELL', False em caso contrário;
  • by_amount: True se a ordem foi definida por amount, False em caso contrário;
  • by_size: True se a ordem foi definida por size, False em caso contrário;
  • amount: amount definido no envio da ordem;
  • size: size definido no envio da ordem;
  • executed_amount: volume financeiro que a ordem já executou;
  • executed_size: quantidade de ações que a ordem já executou;
  • remaining_amount: volume financeiro pendentes na ordem;
  • remaining_size: volume financeiro pendentes na ordem;
  • limit: limit definido no envio da ordem;
  • average_executed_price: preço ponderado por volume de todas as execuções da ordem;
  • commission: comissão total já paga pela ordem;
  • time_in_force: time_in_force definido no envio da ordem;
  • expiration_date: time_in_force definido no envio da ordem;
  • status: estado atual da ordem;
  • pending_submit: True se o status da ordem é 'PENDING_SUBMIT', False em caso contrário;
  • submitted: True se o status da ordem é 'SUBMITTED', False em caso contrário;
  • finalized: True se o status da ordem é 'FILLED', 'CANCELLED' ou 'REJECTED', False em caso contrário;
  • partial_filled: True se o status da ordem é 'PARTIAL_FILLED', False em caso contrário;
  • filled: True se o status da ordem é 'FILLED', False em caso contrário;
  • rejected: True se o status da ordem é 'REJECTED', False em caso contrário;
  • pending_cancel: True se o status da ordem é 'PENDING_CANCEL', False em caso contrário;
  • cancelled: True se o status da ordem é 'CANCELLED', False em caso contrário;
  • cancel_reject_reason: string com o motivo do cancelamento ou rejeição se a ordem tiver sido cancelada ou rejeitada, None em caso contrário;
  • cancel: método para cancelar a ordem diretamente pelo objeto (order.cancel());
  • is_market: True se a ordem for do tipo 'Market', False em caso contrário (retorna False);
  • is_limit: True se a ordem for do tipo 'Limit', False em caso contrário (retorna True);
  • is_stop: True se a ordem for do tipo 'Stop', False em caso contrário (retorna False);
  • is_stop_limit: True se a ordem for do tipo 'StopLimit', False em caso contrário (retorna False);
  • is_twap: True se a ordem for do tipo 'TWAP', False em caso contrário (retorna False);
  • is_vwap: True se a ordem for do tipo 'VWAP', False em caso contrário (retorna False);
  • is_trailing_stop: True se a ordem for do tipo 'TrailingStop', False em caso contrário (retorna False);
  • is_bracket: True se a ordem for do tipo 'Bracket', False em caso contrário (retorna False);

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    def on_init(self):
        self.instr_PETR4 = data.subscribe.price_bar('PETR4')

    ...

    def on_day_open(self):
        # Envia uma ordem de venda de um lote de 1000 ações no ativo ABEV3 com limite de preço de venda de R$22.10 por ativo com validade até o fechamento do mercado no dia.
        limit_order = order.send.limit(
            instrument=self.instr_ABEV3,
            side=order.fields.side.SELL,
            size=1000,
            limit=22.1,
            time_in_force=order.fields.time_in_force.GOOD_FOR_A_DAY,
        )

        print(limit_order)

    def on_order_status(self, exec_info):
        print(exec_info)

send.stop()

Descrição:
Método usado para enviar uma ordem com preço de stop. Isto é, define-se um preço no qual a ordem será convertida em uma ordem a mercado. É utilizada normalmente para encerrar uma posição por excesso de prejuízo (stop loss) ou realização de lucro (take profit).

Chamada:
order.send.stop(instrument, side, amount, size, stop, time_in_force, expiration_date, ooreason, distributed, target)

  • instruments: Lista ou dicionário de instrumentos negociáveis para pesos na basket
    • Define o(s) ativo(s) que será comprado ou vendido pela ordem. Se definidos no formato de dicionário, os valores serão considerados pesos que multiplicam o amount/size de cada ativo (se distributed=True, os pesos serão normalizados). Se um peso for negativo, ele reverterá o side daquele ativo. Se for enviada uma lista de instrumentos, será considerado peso unitário para cada um.
  • distributed: bool, default True.
    • Se True, os pesos definidos em instruments serão normalizados (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$250.000,00 em PETR3 e R$750.000,00 em BPAC11). Se False, os pesos definidos serão tomados sem normalização (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$1.000.000,00 em PETR3 e R$3.000.000,00 em BPAC11).
  • side: string, default None (será inferido como 'BUY' ou 'SELL' pelo sinal de amount ou size)
    • Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL').
  • size: número, default None (amount deve ser especificado)
    • Tamanho do lote (quantidade de ativos) da ordem.
  • amount: número, default None (size deve ser especificado)
    • Volume financeiro da ordem.
  • stop: Número ou dicionário de instrumentos para os stops individuais de cada ativo
    • Limite de preço em que a ordem será ativada. Se mais de um ativo for definido em instrument e stop for um número, este número será tomado como preço stop de todos os ativos. Se stop for um dicionário especificando os stops específicos de cada ativo, deverá definir todos os ativos que constam em instruments.
  • time_in_force: string, default 'GTC'.
    • Validade da ordem ['GFD' (GOOD_FOR_A_DAY), 'GTC' (GOOD_TILL_CANCEL), 'IOC' (IMMEDIATE_OR_CANCEL) ou 'GTD' (GOOD_TILL_DATE)].
  • expiration_date: datetime.datetime, default None.
    • Data de expiração da ordem. Válido apenas para time_in_force='GTD'.
  • ooreason: string, default None.
    • Razão pela qual se enviou a ordem (apenas para controle, não surte efeito na execução).
  • target: bool, default False.
    • Se True, a ordem será gerada de forma que, após sua execução, o amount/size definido seja atingido. Por exemplo, uma ordem com target=True e size nulo será convertida em uma ordem de fechamento de todas as posições possuídas. Atenção: As ordens com execuções pendentes não serão levadas em conta. Considere cancelar as ordens pendentes antes do envio da ordem target.

Retorno:
Retorna o objeto da ordem criada, contendo os seguintes campos:

  • id: ID da ordem;
  • instrument: Instrumento que a ordem opera;
  • type: Tipo da ordem (retorna 'Stop');
  • submit_time: Horário de criação da ordem;
  • ooreason: Campo ooreason preenchido no envio da ordem;
  • side: Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL');
  • buy: True se a ordem tem side 'BUY' ou 'BUY_COVER', False em caso contrário;
  • sell: True se a ordem tem side 'SELL' ou 'SHORT_SELL', False em caso contrário;
  • by_amount: True se a ordem foi definida por amount, False em caso contrário;
  • by_size: True se a ordem foi definida por size, False em caso contrário;
  • amount: amount definido no envio da ordem;
  • size: size definido no envio da ordem;
  • executed_amount: volume financeiro que a ordem já executou;
  • executed_size: quantidade de ações que a ordem já executou;
  • remaining_amount: volume financeiro pendentes na ordem;
  • remaining_size: volume financeiro pendentes na ordem;
  • stop: stop definido no envio da ordem;
  • average_executed_price: preço ponderado por volume de todas as execuções da ordem;
  • commission: comissão total já paga pela ordem;
  • time_in_force: time_in_force definido no envio da ordem;
  • expiration_date: time_in_force definido no envio da ordem;
  • status: estado atual da ordem;
  • pending_submit: True se o status da ordem é 'PENDING_SUBMIT', False em caso contrário;
  • submitted: True se o status da ordem é 'SUBMITTED', False em caso contrário;
  • finalized: True se o status da ordem é 'FILLED', 'CANCELLED' ou 'REJECTED', False em caso contrário;
  • partial_filled: True se o status da ordem é 'PARTIAL_FILLED', False em caso contrário;
  • filled: True se o status da ordem é 'FILLED', False em caso contrário;
  • rejected: True se o status da ordem é 'REJECTED', False em caso contrário;
  • pending_cancel: True se o status da ordem é 'PENDING_CANCEL', False em caso contrário;
  • cancelled: True se o status da ordem é 'CANCELLED', False em caso contrário;
  • cancel_reject_reason: string com o motivo do cancelamento ou rejeição se a ordem tiver sido cancelada ou rejeitada, None em caso contrário;
  • cancel: método para cancelar a ordem diretamente pelo objeto (order.cancel());
  • is_market: True se a ordem for do tipo 'Market', False em caso contrário (retorna False);
  • is_limit: True se a ordem for do tipo 'Limit', False em caso contrário (retorna False);
  • is_stop: True se a ordem for do tipo 'Stop', False em caso contrário (retorna True);
  • is_stop_limit: True se a ordem for do tipo 'StopLimit', False em caso contrário (retorna False);
  • is_twap: True se a ordem for do tipo 'TWAP', False em caso contrário (retorna False);
  • is_vwap: True se a ordem for do tipo 'VWAP', False em caso contrário (retorna False);
  • is_trailing_stop: True se a ordem for do tipo 'TrailingStop', False em caso contrário (retorna False);
  • is_bracket: True se a ordem for do tipo 'Bracket', False em caso contrário (retorna False);

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    def on_init(self):
        self.instr_PETR4 = data.subscribe.price_bar('PETR4')

    ...

    def on_day_open(self):
        # Envia uma ordem de compra de um lote de 10000 ações no ativo ABEV3 com preço de stop de R$20.00 por ativo com validade indeterminada. Isto é, se o preço do ativo descer até R$20.00, a ordem stop se converterá em mercado e será executada.
        stop_order = order.send.stop(
            instrument=self.instr_PETR4,
            side=order.fields.side.BUY,
            size=10000,
            stop=20,
            time_in_force=order.fields.time_in_force.GOOD_TILL_CANCEL,
            ooreason='stop loss',
        )

        print(stop_order)

    def on_order_status(self, exec_info):
        print(exec_info)

send.stop_limit()

Descrição:
Método usado para enviar uma ordem com preço de stop e preço de limit. Isto é, define-se um preço no qual a ordem será convertida em uma ordem limite.

Chamada:
order.send.stop_limit(instrument, side, amount, size, stop, limit, time_in_force, expiration_date, ooreason, distributed, target)

  • instruments: Lista ou dicionário de instrumentos negociáveis para pesos na basket
    • Define o(s) ativo(s) que será comprado ou vendido pela ordem. Se definidos no formato de dicionário, os valores serão considerados pesos que multiplicam o amount/size de cada ativo (se distributed=True, os pesos serão normalizados). Se um peso for negativo, ele reverterá o side daquele ativo. Se for enviada uma lista de instrumentos, será considerado peso unitário para cada um.
  • distributed: bool, default True.
    • Se True, os pesos definidos em instruments serão normalizados (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$250.000,00 em PETR3 e R$750.000,00 em BPAC11). Se False, os pesos definidos serão tomados sem normalização (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$1.000.000,00 em PETR3 e R$3.000.000,00 em BPAC11).
  • side: string, default None (será inferido como 'BUY' ou 'SELL' pelo sinal de amount ou size)
    • Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL').
  • size: número, default None (amount deve ser especificado)
    • Tamanho do lote (quantidade de ativos) da ordem.
  • amount: número, default None (size deve ser especificado)
    • Volume financeiro da ordem.
  • stop: Número ou dicionário de instrumentos para os stops individuais de cada ativo
    • Limite de preço em que a ordem será ativada. Se mais de um ativo for definido em instrument e stop for um número, este número será tomado como preço stop de todos os ativos. Se stop for um dicionário especificando os stops específicos de cada ativo, deverá definir todos os ativos que constam em instruments.
  • limit: Número ou dicionário de instrumentos para os limites individuais de cada ativo
    • Limite de preço em que a ordem pode ser executada. Se mais de um ativo for definido em instrument e limit for um número, este número será tomado como preço limite de todos os ativos. Se limit for um dicionário especificando os limites específicos de cada ativo, deverá definir todos os ativos que constam em instruments.
  • time_in_force: string, default 'GTC'.
    • Validade da ordem ['GFD' (GOOD_FOR_A_DAY), 'GTC' (GOOD_TILL_CANCEL), 'IOC' (IMMEDIATE_OR_CANCEL) ou 'GTD' (GOOD_TILL_DATE)].
  • expiration_date: datetime.datetime, default None.
    • Data de expiração da ordem. Válido apenas para time_in_force='GTD'.
  • ooreason: string, default None.
    • Razão pela qual se enviou a ordem (apenas para controle, não surte efeito na execução).
  • target: bool, default False.
    • Se True, a ordem será gerada de forma que, após sua execução, o amount/size definido seja atingido. Por exemplo, uma ordem com target=True e size nulo será convertida em uma ordem de fechamento de todas as posições possuídas. Atenção: As ordens com execuções pendentes não serão levadas em conta. Considere cancelar as ordens pendentes antes do envio da ordem target.

Retorno:
Retorna o objeto da ordem criada, contendo os seguintes campos:

  • id: ID da ordem;
  • instrument: Instrumento que a ordem opera;
  • type: Tipo da ordem (retorna 'StopLimit');
  • submit_time: Horário de criação da ordem;
  • ooreason: Campo ooreason preenchido no envio da ordem;
  • side: Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL');
  • buy: True se a ordem tem side 'BUY' ou 'BUY_COVER', False em caso contrário;
  • sell: True se a ordem tem side 'SELL' ou 'SHORT_SELL', False em caso contrário;
  • by_amount: True se a ordem foi definida por amount, False em caso contrário;
  • by_size: True se a ordem foi definida por size, False em caso contrário;
  • amount: amount definido no envio da ordem;
  • size: size definido no envio da ordem;
  • executed_amount: volume financeiro que a ordem já executou;
  • executed_size: quantidade de ações que a ordem já executou;
  • remaining_amount: volume financeiro pendentes na ordem;
  • remaining_size: volume financeiro pendentes na ordem;
  • stop: stop definido no envio da ordem;
  • limit: limit definido no envio da ordem;
  • average_executed_price: preço ponderado por volume de todas as execuções da ordem;
  • commission: comissão total já paga pela ordem;
  • time_in_force: time_in_force definido no envio da ordem;
  • expiration_date: time_in_force definido no envio da ordem;
  • status: estado atual da ordem;
  • pending_submit: True se o status da ordem é 'PENDING_SUBMIT', False em caso contrário;
  • submitted: True se o status da ordem é 'SUBMITTED', False em caso contrário;
  • finalized: True se o status da ordem é 'FILLED', 'CANCELLED' ou 'REJECTED', False em caso contrário;
  • partial_filled: True se o status da ordem é 'PARTIAL_FILLED', False em caso contrário;
  • filled: True se o status da ordem é 'FILLED', False em caso contrário;
  • rejected: True se o status da ordem é 'REJECTED', False em caso contrário;
  • pending_cancel: True se o status da ordem é 'PENDING_CANCEL', False em caso contrário;
  • cancelled: True se o status da ordem é 'CANCELLED', False em caso contrário;
  • cancel_reject_reason: string com o motivo do cancelamento ou rejeição se a ordem tiver sido cancelada ou rejeitada, None em caso contrário;
  • cancel: método para cancelar a ordem diretamente pelo objeto (order.cancel());
  • is_market: True se a ordem for do tipo 'Market', False em caso contrário (retorna False);
  • is_limit: True se a ordem for do tipo 'Limit', False em caso contrário (retorna False);
  • is_stop: True se a ordem for do tipo 'Stop', False em caso contrário (retorna False);
  • is_stop_limit: True se a ordem for do tipo 'StopLimit', False em caso contrário (retorna True);
  • is_twap: True se a ordem for do tipo 'TWAP', False em caso contrário (retorna False);
  • is_vwap: True se a ordem for do tipo 'VWAP', False em caso contrário (retorna False);
  • is_trailing_stop: True se a ordem for do tipo 'TrailingStop', False em caso contrário (retorna False);
  • is_bracket: True se a ordem for do tipo 'Bracket', False em caso contrário (retorna False);

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    def on_init(self):
        self.instr_PETR4 = data.subscribe.price_bar('PETR4')

    ...

    def on_day_open(self):
        # Envia uma ordem de venda com preço de stop de R$16,00 e preço de limite de R$18,00 de um lote de 1000 unidades do ativo PETR4 com validade do dia.
        stop_limit_order = order.send.stop_limit(
            instrument=self.instr_PETR4,
            side=order.fields.side.SELL,
            size=1000,
            stop=16,
            limit=18,
            time_in_force=order.fields.time_in_force.GOOD_FOR_A_DAY,
        )

        print(stop_limit_order)

    def on_order_status(self, exec_info):
        print(exec_info)

send.twap()

Descrição:
Método usado para enviar uma ordem de TWAP (Time Weighted Average Price). Esse tipo de ordem pondera seu tamanho ao longo do tempo, fazendo com que não seja enviado o volume total da ordem de uma vez só (o que traria alto impacto no mercado no preço médio final) e, sim, por fatias. As ordens TWAP sempre expirarão no fechamento do mercado.

Chamada:
order.send.twap(instrument, time_length, num_slices, side, amount, size, limit, time_in_force, expiration_date, ooreason, distributed, target)

  • instruments: Lista ou dicionário de instrumentos negociáveis para pesos na basket
    • Define o(s) ativo(s) que será comprado ou vendido pela ordem. Se definidos no formato de dicionário, os valores serão considerados pesos que multiplicam o amount/size de cada ativo (se distributed=True, os pesos serão normalizados). Se um peso for negativo, ele reverterá o side daquele ativo. Se for enviada uma lista de instrumentos, será considerado peso unitário para cada um.
  • time_length: datetime.timedelta.
    • Período durante o qual a ordem ficará ativa.
  • num_slices: Número inteiro.
    • Número de fatias para execução da ordem.
  • distributed: bool, default True.
    • Se True, os pesos definidos em instruments serão normalizados (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$250.000,00 em PETR3 e R$750.000,00 em BPAC11). Se False, os pesos definidos serão tomados sem normalização (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$1.000.000,00 em PETR3 e R$3.000.000,00 em BPAC11).
  • side: string, default None (será inferido como 'BUY' ou 'SELL' pelo sinal de amount ou size)
    • Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL').
  • size: número, default None (amount deve ser especificado)
    • Tamanho do lote (quantidade de ativos) da ordem.
  • amount: número, default None (size deve ser especificado)
    • Volume financeiro da ordem.
  • limit: Número ou dicionário de instrumentos para os limites individuais de cada ativo, default None (ordem não terá limite)
    • Limite de preço em que a ordem pode ser executada. Se mais de um ativo for definido em instrument e limit for um número, este número será tomado como preço limite de todos os ativos. Se limit for um dicionário especificando os limites específicos de cada ativo, deverá definir todos os ativos que constam em instruments.
  • time_in_force: string, default 'GTC'.
    • Validade da ordem ['GFD' (GOOD_FOR_A_DAY), 'GTC' (GOOD_TILL_CANCEL), 'IOC' (IMMEDIATE_OR_CANCEL) ou 'GTD' (GOOD_TILL_DATE)].
  • expiration_date: datetime.datetime, default None.
    • Data de expiração da ordem. Válido apenas para time_in_force='GTD'.
  • ooreason: string, default None.
    • Razão pela qual se enviou a ordem (apenas para controle, não surte efeito na execução).
  • target: bool, default False.
    • Se True, a ordem será gerada de forma que, após sua execução, o amount/size definido seja atingido. Por exemplo, uma ordem com target=True e size nulo será convertida em uma ordem de fechamento de todas as posições possuídas. Atenção: As ordens com execuções pendentes não serão levadas em conta. Considere cancelar as ordens pendentes antes do envio da ordem target.

Retorno:
Retorna o objeto da ordem criada, contendo os seguintes campos:

  • id: ID da ordem;
  • instrument: Instrumento que a ordem opera;
  • type: Tipo da ordem (retorna 'TWAP');
  • submit_time: Horário de criação da ordem;
  • ooreason: Campo ooreason preenchido no envio da ordem;
  • side: Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL');
  • buy: True se a ordem tem side 'BUY' ou 'BUY_COVER', False em caso contrário;
  • sell: True se a ordem tem side 'SELL' ou 'SHORT_SELL', False em caso contrário;
  • by_amount: True se a ordem foi definida por amount, False em caso contrário;
  • by_size: True se a ordem foi definida por size, False em caso contrário;
  • amount: amount definido no envio da ordem;
  • size: size definido no envio da ordem;
  • executed_amount: volume financeiro que a ordem já executou;
  • executed_size: quantidade de ações que a ordem já executou;
  • remaining_amount: volume financeiro pendentes na ordem;
  • remaining_size: volume financeiro pendentes na ordem;
  • limit: limit definido no envio da ordem;
  • num_slices: número total de fatias da ordem;
  • remaining_slices: número de fatias que ainda não foram enviadas;
  • time_length: comprimento total da ordem;
  • time_step: tempo entre o envio de duas fatias;
  • average_executed_price: preço ponderado por volume de todas as execuções da ordem;
  • commission: comissão total já paga pela ordem;
  • time_in_force: time_in_force definido no envio da ordem;
  • expiration_date: time_in_force definido no envio da ordem;
  • status: estado atual da ordem;
  • pending_submit: True se o status da ordem é 'PENDING_SUBMIT', False em caso contrário;
  • submitted: True se o status da ordem é 'SUBMITTED', False em caso contrário;
  • finalized: True se o status da ordem é 'FILLED', 'CANCELLED' ou 'REJECTED', False em caso contrário;
  • partial_filled: True se o status da ordem é 'PARTIAL_FILLED', False em caso contrário;
  • filled: True se o status da ordem é 'FILLED', False em caso contrário;
  • rejected: True se o status da ordem é 'REJECTED', False em caso contrário;
  • pending_cancel: True se o status da ordem é 'PENDING_CANCEL', False em caso contrário;
  • cancelled: True se o status da ordem é 'CANCELLED', False em caso contrário;
  • cancel_reject_reason: string com o motivo do cancelamento ou rejeição se a ordem tiver sido cancelada ou rejeitada, None em caso contrário;
  • cancel: método para cancelar a ordem diretamente pelo objeto (order.cancel());
  • is_market: True se a ordem for do tipo 'Market', False em caso contrário (retorna False);
  • is_limit: True se a ordem for do tipo 'Limit', False em caso contrário (retorna False);
  • is_stop: True se a ordem for do tipo 'Stop', False em caso contrário (retorna False);
  • is_stop_limit: True se a ordem for do tipo 'StopLimit', False em caso contrário (retorna False);
  • is_twap: True se a ordem for do tipo 'TWAP', False em caso contrário (retorna True);
  • is_vwap: True se a ordem for do tipo 'VWAP', False em caso contrário (retorna False);
  • is_trailing_stop: True se a ordem for do tipo 'TrailingStop', False em caso contrário (retorna False);
  • is_bracket: True se a ordem for do tipo 'Bracket', False em caso contrário (retorna False);

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    def on_init(self):
        self.instr_PETR4 = data.subscribe.price_bar('PETR4')

    ...

    def on_day_open(self):
        # Envia uma ordem de compra com TWAP de um lote de 1000 unidades do ativo PETR4, por 3 horas e com 3 fatias.
        twap_order = order.send.twap(
            instrument=self.instr_PETR4,
            side=order.fields.side.BUY,
            size=1000,
            time_length=timedelta(hours=3),
            num_slices=3,
        )

        print(twap_order)

    def on_order_status(self, exec_info):
        print(exec_info)

send.vwap()

Descrição:
Método usado para enviar uma ordem com VWAP (Volume Weighted Average Price). Esse tipo de ordem pulveriza as compras ou vendas de forma a se aproximar do preço de VWAP do seu período de execução.

Chamada:
order.send.vwap(instrument, side, size, amount, time_in_force, expiration_date, ooreason, distributed, target)

  • instruments: Lista ou dicionário de instrumentos negociáveis para pesos na basket
    • Define o(s) ativo(s) que será comprado ou vendido pela ordem. Se definidos no formato de dicionário, os valores serão considerados pesos que multiplicam o amount/size de cada ativo (se distributed=True, os pesos serão normalizados). Se um peso for negativo, ele reverterá o side daquele ativo. Se for enviada uma lista de instrumentos, será considerado peso unitário para cada um.
  • distributed: bool, default True.
    • Se True, os pesos definidos em instruments serão normalizados (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$250.000,00 em PETR3 e R$750.000,00 em BPAC11). Se False, os pesos definidos serão tomados sem normalização (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$1.000.000,00 em PETR3 e R$3.000.000,00 em BPAC11).
  • side: string, default None (será inferido como 'BUY' ou 'SELL' pelo sinal de amount ou size)
    • Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL').
  • size: número, default None (amount deve ser especificado)
    • Tamanho do lote (quantidade de ativos) da ordem.
  • amount: número, default None (size deve ser especificado)
    • Volume financeiro da ordem.
  • time_in_force: string, default 'GTC'.
    • Validade da ordem ['GFD' (GOOD_FOR_A_DAY), 'GTC' (GOOD_TILL_CANCEL), 'IOC' (IMMEDIATE_OR_CANCEL) ou 'GTD' (GOOD_TILL_DATE)].
  • expiration_date: datetime.datetime, default None.
    • Data de expiração da ordem. Válido apenas para time_in_force='GTD'.
  • ooreason: string, default None.
    • Razão pela qual se enviou a ordem (apenas para controle, não surte efeito na execução).
  • target: bool, default False.
    • Se True, a ordem será gerada de forma que, após sua execução, o amount/size definido seja atingido. Por exemplo, uma ordem com target=True e size nulo será convertida em uma ordem de fechamento de todas as posições possuídas. Atenção: As ordens com execuções pendentes não serão levadas em conta. Considere cancelar as ordens pendentes antes do envio da ordem target.

Retorno:
Retorna o objeto da ordem criada, contendo os seguintes campos:

  • id: ID da ordem;
  • instrument: Instrumento que a ordem opera;
  • type: Tipo da ordem (retorna 'VWAP');
  • submit_time: Horário de criação da ordem;
  • ooreason: Campo ooreason preenchido no envio da ordem;
  • side: Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL');
  • buy: True se a ordem tem side 'BUY' ou 'BUY_COVER', False em caso contrário;
  • sell: True se a ordem tem side 'SELL' ou 'SHORT_SELL', False em caso contrário;
  • by_amount: True se a ordem foi definida por amount, False em caso contrário;
  • by_size: True se a ordem foi definida por size, False em caso contrário;
  • amount: amount definido no envio da ordem;
  • size: size definido no envio da ordem;
  • executed_amount: volume financeiro que a ordem já executou;
  • executed_size: quantidade de ações que a ordem já executou;
  • remaining_amount: volume financeiro pendentes na ordem;
  • remaining_size: volume financeiro pendentes na ordem;
  • average_executed_price: preço ponderado por volume de todas as execuções da ordem;
  • commission: comissão total já paga pela ordem;
  • time_in_force: time_in_force definido no envio da ordem;
  • expiration_date: time_in_force definido no envio da ordem;
  • status: estado atual da ordem;
  • pending_submit: True se o status da ordem é 'PENDING_SUBMIT', False em caso contrário;
  • submitted: True se o status da ordem é 'SUBMITTED', False em caso contrário;
  • finalized: True se o status da ordem é 'FILLED', 'CANCELLED' ou 'REJECTED', False em caso contrário;
  • partial_filled: True se o status da ordem é 'PARTIAL_FILLED', False em caso contrário;
  • filled: True se o status da ordem é 'FILLED', False em caso contrário;
  • rejected: True se o status da ordem é 'REJECTED', False em caso contrário;
  • pending_cancel: True se o status da ordem é 'PENDING_CANCEL', False em caso contrário;
  • cancelled: True se o status da ordem é 'CANCELLED', False em caso contrário;
  • cancel_reject_reason: string com o motivo do cancelamento ou rejeição se a ordem tiver sido cancelada ou rejeitada, None em caso contrário;
  • cancel: método para cancelar a ordem diretamente pelo objeto (order.cancel());
  • is_market: True se a ordem for do tipo 'Market', False em caso contrário (retorna False);
  • is_limit: True se a ordem for do tipo 'Limit', False em caso contrário (retorna False);
  • is_stop: True se a ordem for do tipo 'Stop', False em caso contrário (retorna False);
  • is_stop_limit: True se a ordem for do tipo 'StopLimit', False em caso contrário (retorna False);
  • is_twap: True se a ordem for do tipo 'TWAP', False em caso contrário (retorna False);
  • is_vwap: True se a ordem for do tipo 'VWAP', False em caso contrário (retorna True);
  • is_trailing_stop: True se a ordem for do tipo 'TrailingStop', False em caso contrário (retorna False);
  • is_bracket: True se a ordem for do tipo 'Bracket', False em caso contrário (retorna False);

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    def on_init(self):
        self.instr_PETR4 = data.subscribe.price_bar('PETR4')

    ...

    def on_day_open(self):
        # Envia uma ordem VWAP de compra de R$100,000.00 no ativo PETR4 com validade até o fechamento do mercado no dia.
        vwap_order = order.send.vwap(
            instrument=self.instr_PETR4,
            amount=100000,
            time_in_force=order.fields.time_in_force.GOOD_FOR_A_DAY,
        )

        print(vwap_order)

    def on_order_status(self, exec_info):
        print(exec_info)

send.trailing_stop()

Descrição:
Método usado para enviar uma ordem com stop_loss automático. Isto é, a ordem será executada normalmente (VWAP, se vwap for True, limite, se limit for especificado e mercado, caso contrário) e, caso a tolerância de perda seja atingida (stop_loss), ordens a mercado serão emitidas para fechar a posição e interromper a perda.

Chamada:
order.send.trailing_stop(instrument, stop_loss, limit, vwap, side, amount, size, limit, time_in_force, expiration_date, ooreason, distributed, target)

  • instruments: Lista ou dicionário de instrumentos negociáveis para pesos na basket
    • Define o(s) ativo(s) que será comprado ou vendido pela ordem. Se definidos no formato de dicionário, os valores serão considerados pesos que multiplicam o amount/size de cada ativo (se distributed=True, os pesos serão normalizados). Se um peso for negativo, ele reverterá o side daquele ativo. Se for enviada uma lista de instrumentos, será considerado peso unitário para cada um.
  • distributed: bool, default True.
    • Se True, os pesos definidos em instruments serão normalizados (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$250.000,00 em PETR3 e R$750.000,00 em BPAC11). Se False, os pesos definidos serão tomados sem normalização (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$1.000.000,00 em PETR3 e R$3.000.000,00 em BPAC11).
  • side: string, default None (será inferido como 'BUY' ou 'SELL' pelo sinal de amount ou size)
    • Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL').
  • size: número, default None (amount deve ser especificado)
    • Tamanho do lote (quantidade de ativos) da ordem.
  • amount: número, default None (size deve ser especificado)
    • Volume financeiro da ordem.
  • stop_loss: Número ou dicionário de instrumentos para os stop_loss individuais de cada ativo
    • Limite de perda desde a posição mais valorizada em que a posição inicialmente gerada pela ordem será encerrada.
  • limit: Número ou dicionário de instrumentos para os limites individuais de cada ativo, default None (ordem não terá limite)
    • Limite de preço em que a ordem pode ser executada. Se mais de um ativo for definido em instrument e limit for um número, este número será tomado como preço limite de todos os ativos. Se limit for um dicionário especificando os limites específicos de cada ativo, deverá definir todos os ativos que constam em instruments.
  • vwap: bool, default False
    • Se True, a ordem inicial que abre a posição será do tipo VWAP.
  • time_in_force: string, default 'GTC'.
    • Validade da ordem ['GFD' (GOOD_FOR_A_DAY), 'GTC' (GOOD_TILL_CANCEL), 'IOC' (IMMEDIATE_OR_CANCEL) ou 'GTD' (GOOD_TILL_DATE)].
  • expiration_date: datetime.datetime, default None.
    • Data de expiração da ordem. Válido apenas para time_in_force='GTD'.
  • ooreason: string, default None.
    • Razão pela qual se enviou a ordem (apenas para controle, não surte efeito na execução).
  • target: bool, default False.
    • Se True, a ordem será gerada de forma que, após sua execução, o amount/size definido seja atingido. Por exemplo, uma ordem com target=True e size nulo será convertida em uma ordem de fechamento de todas as posições possuídas. Atenção: As ordens com execuções pendentes não serão levadas em conta. Considere cancelar as ordens pendentes antes do envio da ordem target.

Retorno:
Retorna o objeto da ordem criada, contendo os seguintes campos:

  • id: ID da ordem;
  • instrument: Instrumento que a ordem opera;
  • type: Tipo da ordem (retorna 'TrailingStop');
  • submit_time: Horário de criação da ordem;
  • ooreason: Campo ooreason preenchido no envio da ordem;
  • side: Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL');
  • buy: True se a ordem tem side 'BUY' ou 'BUY_COVER', False em caso contrário;
  • sell: True se a ordem tem side 'SELL' ou 'SHORT_SELL', False em caso contrário;
  • by_amount: True se a ordem foi definida por amount, False em caso contrário;
  • by_size: True se a ordem foi definida por size, False em caso contrário;
  • amount: amount definido no envio da ordem;
  • size: size definido no envio da ordem;
  • executed_amount: volume financeiro que a ordem já executou;
  • executed_size: quantidade de ações que a ordem já executou;
  • remaining_amount: volume financeiro pendentes na ordem;
  • remaining_size: volume financeiro pendentes na ordem;
  • stop_loss: stop_loss definido no envio da ordem;
  • limit: limit definido no envio da ordem (None se nenhum limite foi definido);
  • vwap: opção de vwap definida no envio da ordem;
  • average_executed_price: preço ponderado por volume de todas as execuções da ordem;
  • commission: comissão total já paga pela ordem;
  • time_in_force: time_in_force definido no envio da ordem;
  • expiration_date: time_in_force definido no envio da ordem;
  • status: estado atual da ordem;
  • pending_submit: True se o status da ordem é 'PENDING_SUBMIT', False em caso contrário;
  • submitted: True se o status da ordem é 'SUBMITTED', False em caso contrário;
  • finalized: True se o status da ordem é 'FILLED', 'CANCELLED' ou 'REJECTED', False em caso contrário;
  • partial_filled: True se o status da ordem é 'PARTIAL_FILLED', False em caso contrário;
  • filled: True se o status da ordem é 'FILLED', False em caso contrário;
  • rejected: True se o status da ordem é 'REJECTED', False em caso contrário;
  • pending_cancel: True se o status da ordem é 'PENDING_CANCEL', False em caso contrário;
  • cancelled: True se o status da ordem é 'CANCELLED', False em caso contrário;
  • cancel_reject_reason: string com o motivo do cancelamento ou rejeição se a ordem tiver sido cancelada ou rejeitada, None em caso contrário;
  • cancel: método para cancelar a ordem diretamente pelo objeto (order.cancel());
  • is_market: True se a ordem for do tipo 'Market', False em caso contrário (retorna False);
  • is_limit: True se a ordem for do tipo 'Limit', False em caso contrário (retorna False);
  • is_stop: True se a ordem for do tipo 'Stop', False em caso contrário (retorna False);
  • is_stop_limit: True se a ordem for do tipo 'StopLimit', False em caso contrário (retorna False);
  • is_twap: True se a ordem for do tipo 'TWAP', False em caso contrário (retorna False);
  • is_vwap: True se a ordem for do tipo 'VWAP', False em caso contrário (retorna False);
  • is_trailing_stop: True se a ordem for do tipo 'TrailingStop', False em caso contrário (retorna True);
  • is_bracket: True se a ordem for do tipo 'Bracket', False em caso contrário (retorna False);

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    def on_init(self):
        self.instr_PETR4 = data.subscribe.price_bar('PETR4')

    ...

    def on_day_open(self):
        # Envia uma ordem de venda com tolerância a 10% de perda na posição e tipo VWAP de um lote de 1000 unidades do ativo PETR4.
        trailing_stop_order = order.send.trailing_stop(
            instrument=self.instr_PETR4,
            side=order.fields.side.SELL,
            size=1000,
            stop_loss=10,
            limit=18,
        )

        print(trailing_stop_order)

    def on_order_status(self, exec_info):
        print(exec_info)

send.bracket()

Descrição:
Método usado para enviar uma ordem com stop_loss e take_profit automático. Isto é, a ordem será executada normalmente (VWAP, se vwap for True, limite, se limit for especificado e mercado, caso contrário) e, caso a tolerância de perda (stop_loss) ou o retorno desejado (take_profit) sejam atingidos, ordens a mercado serão emitidas para fechar a posição e interromper a perda ou realizar o ganho.

Chamada:
order.send.bracket(instrument, stop_loss, take_profit, limit, vwap, side, amount, size, limit, time_in_force, expiration_date, ooreason, distributed, target)

  • instruments: Lista ou dicionário de instrumentos negociáveis para pesos na basket
    • Define o(s) ativo(s) que será comprado ou vendido pela ordem. Se definidos no formato de dicionário, os valores serão considerados pesos que multiplicam o amount/size de cada ativo (se distributed=True, os pesos serão normalizados). Se um peso for negativo, ele reverterá o side daquele ativo. Se for enviada uma lista de instrumentos, será considerado peso unitário para cada um.
  • distributed: bool, default True.
    • Se True, os pesos definidos em instruments serão normalizados (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$250.000,00 em PETR3 e R$750.000,00 em BPAC11). Se False, os pesos definidos serão tomados sem normalização (e.g.: se instruments={'PETR3': 1, 'BPAC11': 3} e amount=1000000, serão enviadas ordens de R$1.000.000,00 em PETR3 e R$3.000.000,00 em BPAC11).
  • side: string, default None (será inferido como 'BUY' ou 'SELL' pelo sinal de amount ou size)
    • Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL').
  • size: número, default None (amount deve ser especificado)
    • Tamanho do lote (quantidade de ativos) da ordem.
  • amount: número, default None (size deve ser especificado)
    • Volume financeiro da ordem.
  • stop_loss: Número ou dicionário de instrumentos para os stop_loss individuais de cada ativo
    • Limite de perda desde a posição mais valorizada em que a posição inicialmente gerada pela ordem será encerrada.
  • take_profit: Número ou dicionário de instrumentos para os take_profits individuais de cada ativo
    • Limite de ganho desde a posição inicial em que a posição inicialmente gerada pela ordem será encerrada.
  • limit: Número ou dicionário de instrumentos para os limites individuais de cada ativo, default None (ordem não terá limite)
    • Limite de preço em que a ordem pode ser executada. Se mais de um ativo for definido em instrument e limit for um número, este número será tomado como preço limite de todos os ativos. Se limit for um dicionário especificando os limites específicos de cada ativo, deverá definir todos os ativos que constam em instruments.
  • vwap: bool, default False
    • Se True, a ordem inicial que abre a posição será do tipo VWAP.
  • time_in_force: string, default 'GTC'.
    • Validade da ordem ['GFD' (GOOD_FOR_A_DAY), 'GTC' (GOOD_TILL_CANCEL), 'IOC' (IMMEDIATE_OR_CANCEL) ou 'GTD' (GOOD_TILL_DATE)].
  • expiration_date: datetime.datetime, default None.
    • Data de expiração da ordem. Válido apenas para time_in_force='GTD'.
  • ooreason: string, default None.
    • Razão pela qual se enviou a ordem (apenas para controle, não surte efeito na execução).
  • target: bool, default False.
    • Se True, a ordem será gerada de forma que, após sua execução, o amount/size definido seja atingido. Por exemplo, uma ordem com target=True e size nulo será convertida em uma ordem de fechamento de todas as posições possuídas. Atenção: As ordens com execuções pendentes não serão levadas em conta. Considere cancelar as ordens pendentes antes do envio da ordem target.

Retorno:
Retorna o objeto da ordem criada, contendo os seguintes campos:

  • id: ID da ordem;
  • instrument: Instrumento que a ordem opera;
  • type: Tipo da ordem (retorna 'Bracket');
  • submit_time: Horário de criação da ordem;
  • ooreason: Campo ooreason preenchido no envio da ordem;
  • side: Tipo de execução ('BUY', 'BUY_COVER', 'SHORT_SELL' ou 'SELL');
  • buy: True se a ordem tem side 'BUY' ou 'BUY_COVER', False em caso contrário;
  • sell: True se a ordem tem side 'SELL' ou 'SHORT_SELL', False em caso contrário;
  • by_amount: True se a ordem foi definida por amount, False em caso contrário;
  • by_size: True se a ordem foi definida por size, False em caso contrário;
  • amount: amount definido no envio da ordem;
  • size: size definido no envio da ordem;
  • executed_amount: volume financeiro que a ordem já executou;
  • executed_size: quantidade de ações que a ordem já executou;
  • remaining_amount: volume financeiro pendentes na ordem;
  • remaining_size: volume financeiro pendentes na ordem;
  • stop_loss: stop_loss definido no envio da ordem;
  • take_profit: take_profit definido no envio da ordem;
  • limit: limit definido no envio da ordem (None se nenhum limite foi definido);
  • vwap: opção de vwap definida no envio da ordem;
  • average_executed_price: preço ponderado por volume de todas as execuções da ordem;
  • commission: comissão total já paga pela ordem;
  • time_in_force: time_in_force definido no envio da ordem;
  • expiration_date: time_in_force definido no envio da ordem;
  • status: estado atual da ordem;
  • pending_submit: True se o status da ordem é 'PENDING_SUBMIT', False em caso contrário;
  • submitted: True se o status da ordem é 'SUBMITTED', False em caso contrário;
  • finalized: True se o status da ordem é 'FILLED', 'CANCELLED' ou 'REJECTED', False em caso contrário;
  • partial_filled: True se o status da ordem é 'PARTIAL_FILLED', False em caso contrário;
  • filled: True se o status da ordem é 'FILLED', False em caso contrário;
  • rejected: True se o status da ordem é 'REJECTED', False em caso contrário;
  • pending_cancel: True se o status da ordem é 'PENDING_CANCEL', False em caso contrário;
  • cancelled: True se o status da ordem é 'CANCELLED', False em caso contrário;
  • cancel_reject_reason: string com o motivo do cancelamento ou rejeição se a ordem tiver sido cancelada ou rejeitada, None em caso contrário;
  • cancel: método para cancelar a ordem diretamente pelo objeto (order.cancel());
  • is_market: True se a ordem for do tipo 'Market', False em caso contrário (retorna False);
  • is_limit: True se a ordem for do tipo 'Limit', False em caso contrário (retorna False);
  • is_stop: True se a ordem for do tipo 'Stop', False em caso contrário (retorna False);
  • is_stop_limit: True se a ordem for do tipo 'StopLimit', False em caso contrário (retorna False);
  • is_twap: True se a ordem for do tipo 'TWAP', False em caso contrário (retorna False);
  • is_vwap: True se a ordem for do tipo 'VWAP', False em caso contrário (retorna False);
  • is_trailing_stop: True se a ordem for do tipo 'TrailingStop', False em caso contrário (retorna False);
  • is_bracket: True se a ordem for do tipo 'Bracket', False em caso contrário (retorna True);

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from dorothy import StrategyBase, data, order

class Strategy(StrategyBase):

    def on_init(self):
        self.instr_PETR4 = data.subscribe.price_bar('PETR4')

    ...

    def on_day_open(self):
        # Envia uma ordem de venda com tolerância a 10% de perda na posição e objetivo de lucro de 20% e com preço de limite de 18 reais de um lote de 1000 ações do ativo PETR4.
        bracket_order = order.send.bracket(
            instrument=self.instr_PETR4,
            side=order.fields.side.SELL,
            size=1000,
            stop_loss=10,
            take_profit=20,
            limit=18,
        )

        print(bracket_order)

    def on_order_status(self, exec_info):
        print(exec_info)

Position


balance()

Descrição:
Método usado para verificar o saldo da estratégia segregado por moedas.

Chamada:
position.balance(currencies, base_currency, total)

  • currencies: Default None (refere-se a todas as moedas ativas).
    • Moedas das quais se deseja obter o saldo.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.
  • total: bool, default False.
    • Se True, os valores selecionados serão somados e um número será retornado em vez de um dicionário. Se mais uma moeda tiver valor não nulo e base_currency não for True, um erro será gerado.

Retorno:
Retorna um dicionário com o saldo separado por moedas.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from dorothy import StrategyBase, position

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        # Recupera o saldo total da estratégia convertido para a moeda base.
        # Por default, não são considerados saldos bloqueados.
        self.balance = position.balance(base_currency=True, total=True)

cash()

Descrição:
Método usado para verificar o caixa da estratégia separado por moeda.

Chamada:
position.cash(currencies, base_currency, total, best_case, worst_case)

  • currencies: Default None (refere-se a todas as moedas ativas).
    • Moedas das quais se deseja obter o valor.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.
  • total: bool, default False.
    • Se True, os valores selecionados serão somados. Se mais uma moeda tiver valor não nulo e base_currency não for True, um erro será gerado.
  • best_case: bool, default False.
    • Se True, será considerada a entrada de caixa gerada pelas execuções das ordens pendentes que aumentam o caixa.
  • worst_case: bool, default False.
    • Se True, será considerada a entrada de caixa gerada pelas execuções das ordens pendentes que diminuem o caixa.

Retorno:
Retorna um dicionário com o caixa separado por moedas.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_init(self, settings):

        ...

        # Alocando todo o caixa em self.instrument
        order.send.market(
            instrument=self.instrument,
            amount=position.cash(currencies='BRL'),
        )

market_value()

Descrição:
Método usado para verificar o valor de mercado dos ativos da estratégia separado por moeda.

Chamada:
position.market_value(currencies, base_currency, total, long, short)

  • currencies: Default None (refere-se a todas as moedas ativas).
    • Moedas das quais se deseja obter o valor.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.
  • total: bool, default False.
    • Se True, os valores selecionados serão somados. Se mais uma moeda tiver valor não nulo e base_currency não for True, um erro será gerado.
  • long: bool, default False.
    • Se True, serão consideradas apenas as posições long da estratégia.
  • short: bool, default False.
    • Se True, serão consideradas apenas as posições short da estratégia.

Retorno:
Retorna um dicionário com o valor de mercado separado por moedas.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_bar_close(self, settings):

        ...

        market_value = position.market_value()

        print(f'market_value: {market_value}')

total_capital()

Descrição:
Método usado para verificar o capital total da estratégia separado por moeda.

Chamada:
position.total_capital(currencies, base_currency, total)

  • currencies: Default None (refere-se a todas as moedas ativas).
    • Moedas das quais se deseja obter o valor.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.
  • total: bool, default False.
    • Se True, os valores selecionados serão somados. Se mais uma moeda tiver valor não nulo e base_currency não for True, um erro será gerado.

Retorno:
Retorna um dicionário com o capital total separado por moedas.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_bar_close(self, settings):

        ...

        market_value = position.total_capital()

        print(f'total_capital: {total_capital}')

amount()

Descrição:
Método usado para verificar os valores de mercado (volumes financeiros investidos) atuais dos ativos.

Chamada:
position.amount(instruments, base_currency, total, currency_filter, filter_long, filter_short, outstanding, expected)

  • instruments: Lista de instrumentos negociáveis, default None (refere-se a todos os instrumentos negociáveis assinados).
    • Especifica quais instrumentos terão suas posições contabilizadas.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.
  • total: bool, default False.
    • Se True, os valores selecionados serão somados. Se mais uma moeda tiver valor não nulo e base_currency não for True, um erro será gerado.
  • currency_filter: Lista de moedas.
    • Filtra os instrumentos por moeda antes de avaliar seus valores.
  • filter_long: Default False.
    • Filtro de lado das posições. Se for True, apenas as posições long serão adquiridas. Se tanto filter_long quanto filter_short forem True, apenas as posições nulas não serão adquiridas.
  • filter_short: Default False.
    • Filtro de lado das posições. Se for True, apenas as posições short serão adquiridas. Se tanto filter_long quanto filter_short forem True, apenas as posições nulas não serão adquiridas.
  • outstanding: bool, default False.
    • Se True, apenas os valores previstos em ordens pendentes de execução serão recuperados.
  • expected: bool, default False.
    • Se True, os valores previstos em ordens pendentes de execução serão levados em conta (equivale a uma chamado com outstanding=False somada a outra com outstanding=True).

Retorno:
Retorna as atuais posições da estratégia em um dicionário identificado pelos ativos.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        # Recupera a posição total da estratégia convertida para a moeda base, para cada ativo.
        # Por default, são consideradas todas as moedas.
        positions = position.amount(base_currency=True, total=True)

amount_by_currency()

Descrição:
Método usado para verificar os valores de mercado (volumes financeiros investidos) atuais dos ativos por moeda.

Chamada:
position.amount_by_currency(currencies, base_currency, total, filter_long, filter_short, outstanding, expected)

  • currencies: Lista de moedas.
    • Especifica quais moedas terão suas posições contabilizadas.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.
  • total: bool, default False.
    • Se True, os valores selecionados serão somados. Se mais uma moeda tiver valor não nulo e base_currency não for True, um erro será gerado.
  • filter_long: Default False.
    • Filtro de lado das posições. Se for True, apenas as posições long serão adquiridas. Se tanto filter_long quanto filter_short forem True, apenas as posições nulas não serão adquiridas.
  • filter_short: Default False.
    • Filtro de lado das posições. Se for True, apenas as posições short serão adquiridas. Se tanto filter_long quanto filter_short forem True, apenas as posições nulas não serão adquiridas.
  • outstanding: bool, default False.
    • Se True, apenas os valores previstos em ordens pendentes de execução serão recuperados.
  • expected: bool, default False.
    • Se True, os valores previstos em ordens pendentes de execução serão levados em conta (equivale a uma chamado com outstanding=False somada a outra com outstanding=True).

Retorno:
Retorna as atuais posições da estratégia identificadas pelas moedas.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        # Recupera a posição total da estratégia convertida para a moeda base, para cada moeda.
        # Por default, são consideradas todas as moedas.
        positions_currencies = position.amount_by_currency(currencies='BRL', base_currency=True, total=True)

size()

Descrição:
Método usado para verificar a quantidade de ações em determinados ativos.

Chamada:
position.size(instruments, filter_long, filter_short, outstanding, expected)

  • instruments: Lista de instrumentos negociáveis, default None (refere-se a todos os instrumentos negociáveis assinados).
    • Especifica quais instrumentos terão suas posições contabilizadas.
  • filter_long: Default False.
    • Filtro de lado das posições. Se for True, apenas as posições long serão adquiridas. Se tanto filter_long quanto filter_short forem True, apenas as posições nulas não serão adquiridas.
  • filter_short: Default False.
    • Filtro de lado das posições. Se for True, apenas as posições short serão adquiridas. Se tanto filter_long quanto filter_short forem True, apenas as posições nulas não serão adquiridas.
  • outstanding: bool, default False.
    • Se True, apenas os valores previstos em ordens pendentes de execução serão recuperados.
  • expected: bool, default False.
    • Se True, os valores previstos em ordens pendentes de execução serão levados em conta (equivale a uma chamado com outstanding=False somada a outra com outstanding=True).

Retorno:
Retorna um dicionário de quantidades de ações segregadas por ativo.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        # Recupera o tamanho das posições.
        # Por default, são consideradas todos os ativos.
        size = position.size()

capital_available_for_short_margin()

Descrição:
Método usado para verificar o capital disponível para alocação em margem de operações de short. Contempla caixa e metade do capital investido em equities.

Chamada:
position.capital_available_for_short_margin(currencies, base_currency, total)

  • currencies: Default None (refere-se a todas as moedas ativas).
    • Moedas das quais se deseja obter o valor.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.
  • total: bool, default False.
    • Se True, os valores selecionados serão somados. Se mais uma moeda tiver valor não nulo e base_currency não for True, um erro será gerado.

Retorno:
Retorna um dicionário com o capital disponível para alocação em margem de operações de short separado por moedas.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        ...
        # Montando a maior posição short possível
        self.capital_available_for_short_margin = position.capital_available_for_short_margin(base_currency=True, total=True)
        order.send.market(instrument=self._instrument, amount=self.capital_available_for_short_margin / self._instrument.short_margin)

capital_in_short_margin()

Descrição:
Método usado para verificar o capital alocado em margens de operações de short.

Chamada:
position.capital_in_short_margin(currencies, base_currency, total)

  • currencies: Default None (refere-se a todas as moedas ativas).
    • Moedas das quais se deseja obter o valor.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.
  • total: bool, default False.
    • Se True, os valores selecionados serão somados. Se mais uma moeda tiver valor não nulo e base_currency não for True, um erro será gerado.

Retorno:
Retorna um dicionário com o capital alocado em margem de operações de short separado por moedas.

Exemplo:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        ...
        capital_in_short_margin = position.capital_in_short_margin(base_currency=True, total=True)
        print(f'capital_in_short_margin: {capital_in_short_margin}')

fx_outstanding()

Descrição:
Método usado para verificar posições pendentes de moeda estrangeira.

Chamada:
position.fx_outstanding(currencies, instruments, base_currency, total)

  • currencies: Lista de moedas, default None (todas as moedas serão avaliadas).
    • Especifica quais moedas terão suas posições contabilizadas.
  • instruments: Lista de FX, default None (refere-se a todas as FX assinadas).
    • Especifica quais instrumentos terão suas posições contabilizadas.
  • filter_long: Default False.
    • Filtro de lado das posições. Se for True, apenas as posições long em moeda de origem serão adquiridas. Se tanto filter_long quanto filter_short forem True, apenas as posições nulas em moeda de origem não serão adquiridas.
  • filter_short: Default False.
    • Filtro de lado das posições. Se for True, apenas as posições short em moeda de origem serão adquiridas. Se tanto filter_long quanto filter_short forem True, apenas as posições nulas em moeda de origem não serão adquiridas.

Retorno:
Retorna um dicionário de posições pendentes de moedas.

Exemplo:

1
2
3
4
5
6
7
8
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        fx_outstanding = position.fx_outstanding(base_currency=True, total=True)

cost()

Descrição:
Método usado para verificar o custo atual de cada posição.

Chamada:
position.cost(instruments, base_currency, total, filter_long, filter_short, expected)

  • instruments: Lista de equities, default None (refere-se a todas as equities assinadas).
    • Especifica quais instrumentos terão suas posições contabilizadas.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.
  • total: bool, default False.
    • Se True, os valores selecionados serão somados. Se mais uma moeda tiver valor não nulo e base_currency não for True, um erro será gerado.
  • filter_long: Default False.
    • Filtro de lado das posições. Se for True, apenas as posições long serão adquiridas. Se tanto filter_long quanto filter_short forem True, apenas as posições nulas não serão adquiridas.
  • filter_short: Default False.
    • Filtro de lado das posições. Se for True, apenas as posições short serão adquiridas. Se tanto filter_long quanto filter_short forem True, apenas as posições nulas não serão adquiridas.
  • expected: bool, default False.
    • Se True, os valores previstos em ordens pendentes de execução serão levados em conta.

Retorno:
Retorna um dicionário com os custos das posições separadas por ativo.

Exemplo:

1
2
3
4
5
6
7
8
9
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        # Recupera o custo de todas as posições de todos os ativos, com conversão para a moeda base.
        cost = position.cost(base_currency=True)

pnl_by_instrument()

Descrição:
Método usado para verificar o P&L de determinados ativos.

Chamada:
position.pnl_by_instrument(instruments, base_currency, total)

  • instruments: Lista de instrumentos negociáveis, default None (refere-se a todos os instrumentos negociáveis assinados).
    • Especifica quais instrumentos terão suas posições contabilizadas.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.
  • total: bool, default False.
    • Se True, os valores selecionados serão somados. Se mais uma moeda tiver valor não nulo e base_currency não for True, um erro será gerado.

Retorno:
Retorna um dicionário com o P&L separado por ativo.

Exemplo:

1
2
3
4
5
6
7
8
9
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        # Recupera o P&L total de todos os ativos com conversão para a moeda base
        pnl_by_instrument = position.pnl_by_instrument(base_currency=True, total=True)

pnl()

Descrição:
Método usado para verificar o P&L da estratégia.

Chamada:
position.pnl(currencies, base_currency, total)

  • currencies: Lista de moedas, default None (todas as moedas serão avaliadas).
    • Especifica quais moedas terão suas posições contabilizadas.
  • base_currency: bool, default False.
    • Se True, todos os valores serão convertidos para a moeda base. Caso contrário (False), os valores serão mantidos em suas moedas originais.
  • total: bool, default False.
    • Se True, os valores selecionados serão somados. Se mais uma moeda tiver valor não nulo e base_currency não for True, um erro será gerado.

Retorno:
Retorna o valor de P&L da estratégia segregado por moeda.

Exemplo:

1
2
3
4
5
6
7
8
9
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        # Recupera o P&L total da estratégia.
        pnl = position.pnl(total=True)


roc()

Descrição:
Método usado para verificar o retorno (Return Over Capital) da estratégia.

Chamada:
position.roc()

Retorno:
Retorna o capital total atual dividido pelo capital total inicial.

Exemplo:

1
2
3
4
5
6
7
8
from dorothy import StrategyBase, position, order

class Strategy(StrategyBase):

    ...

    def on_day_close(self):
        strategy_return = position.roc()

Indicadores Chave de Desempenho (KPIs)

Alguns indicadores (KPI's, do inglês Key Performance Indicators) são apresentados ao final da execução do backtest. A seguir, faz-se uma pequena descrição de cada um deles.

PNL

Profit and Loss (P&L), ou Lucros e Perdas. É o resumo financeiro de receitas, custos e despesas resultantes da execução da estratégia, ou seja, é o valor total possuído ao final da execução - incluindo capital investido - menos o capital inicial da estratégia. Na prática, indica quanto de lucro (ou prejuízo) se obteve durante a execução.

Accumulated Return

Retorno acumulado alcançado pela estratégia ao final da execução, ou seja, é o valor total possuído ao final da execução - incluindo capital investido - dividido pelo capital inicial possuído. Todos os valores são convertidos para a moeda base antes de serem computados, se necessário.

Expected Annualized Return

Estimativa do retorno que a estratégia gerará no período de um ano, medido a partir da inclinação da regressão linear da curva de retorno acumulado por dia (slope).

Stability

Mensura a estabilidade da estratégia através do coeficiente de determinação ( da regressão linear) dos retornos acumulados, ou seja, descreve o quanto os retornos acumulados da estratégia se aproximam de uma reta.

Volatility

Volatilidade anualizada da estratégia. É o desvio padrão dos retornos diários da estratégia extrapolado para o período de um ano (considerando-se apenas os dias úteis).

Sharpe

Retorno médio acima de uma taxa livre de risco ajustado pela volatilidade (risco). Investimentos livres de risco, como título públicos possuem Sharpe igual a zero. Geralmente, quanto maior o Sharpe, mais atrativo é o retorno frente ao risco que assume.

Sortino

Variação de Sharpe que diferencia a volatilidade negativa da volatilidade total, utilizando o desvio padrão com os retornos positivos anulados, restando apenas os negativos (downside deviation).

Max Drawdown

Maximum Drawdown (MDD), ou Perda Máxima, é o mínimo da série temporal com a maior perda (queda) desde o último ponto de máximo retorno acumulado (pico) até o ponto atual (chamada de drawdown). Retrata a maior perda percentual que a estratégia teve durante sua execução.

Beta

Correlação entre a estratégia e um benchmark. Mede o quanto o crescimento/decrescimento da estratégia segue o da economia em geral (que deve retratado pelo benchmark).

Alpha

Este parâmetro estima o quanto a estratégia se destacou positivamente dos retornos retratados pelo benchmark selecionado, ou seja, tenta mensurar quanto retorno a estratégia gerou acima do crescimento/decrescimento natural da economia (que deve ser capturado pelo benchmark). Mostra, portanto, quanto retorno a estratégia gerou por inteligência própria, em contraste a simplesmente seguir uma tendência de crescimento geral da economia.

Information Ratio (IR)

Este parâmetro estima o quão consistentemente a estratégia foi capaz de gerar retornos acima do benchmark selecionado (normalmente representativo do mercado operado). É calculado dividindo-se o retorno extra (diferença das médias anualizadas dos retornos diários da estratégia e do benchmark) pelo desvio padrão da diferença entre os retornos da estratégia e do benchmark de cada dia (tracking error).

Value at Risk (VaR)

Este parâmetro estima o pior caso esperado de retorno diário da estratégia. Seu cálculo é feito assumindo-se distribuição normal nos retornos diários e calculando-se o retorno que limita os 5% inferiores da curva (corresponde a aproximadamente 1.645 desvios padrões à esquerda da média dos retornos).

ppf = percentual point function (inversa da cummulative distribution function (cdf))

Conditional Value at Risk (CVaR)

Este parâmetro estima o pior caso esperado de retorno diário da estratégia. Seu cálculo é feito assumindo-se distribuição normal nos retornos diários e calculando-se o valor esperado dos retornos na porção inferior da curva abaixo de 5% (o ponto de 5% corresponde a aproximadamente 1.645 desvios padrões à esquerda da média dos retornos).

ppf = percentual point function (inversa da cummulative distribution function (cdf))

pdf = probability density function