Estrategia vacía

Empieza con la estructura mínima de una estrategia. Así dispones de los hooks del entorno de ejecución sin introducir todavía modelos alfa ni pipes.

use aq_engine::core::broker::data_feeds::yahoo::YahooFinanceDataFeed;
use aq_engine::core::broker::paper_broker::PaperBroker;
use aq_engine::core::broker::types::{AccountType, Asset, BarData};
use aq_engine::core::broker::UnifiedBroker;
use aq_engine::core::insight::Insight;
use aq_engine::core::strategy::{
    EventStreamType, Strategy, StrategyContext, StrategyMode, StrategyState,
};
use aq_engine::core::utils::timeframe::{TimeFrame, TimeFrameUnit};
use chrono::{Duration, Utc};
use std::collections::HashSet;

pub struct BlankStrategy;

impl Strategy for BlankStrategy {
    fn on_start(&mut self, ctx: &mut dyn StrategyContext) {
        // The main strategy timeframe is registered automatically.
        // This adds a feature bar stream for every symbol in the universe.
        ctx.add_events(
            EventStreamType::Bar,
            Some(TimeFrame::new(15, TimeFrameUnit::Minute)),
        );
    }

    fn init(&mut self, _ctx: &mut dyn StrategyContext, _asset: &Asset) {}

    fn universe(&self, _ctx: &mut dyn StrategyContext) -> HashSet<String> {
        HashSet::from([String::from("AAPL")])
    }

    fn on_bar(&mut self, _ctx: &mut dyn StrategyContext, _symbol: &str, _bar: &BarData) {}

    fn generate_insights(&mut self, _ctx: &mut dyn StrategyContext, _symbol: &str) {}

    fn insight_pipeline(&mut self, _ctx: &mut dyn StrategyContext, _insight: &Insight) {}

    fn on_teardown(&mut self, _ctx: &mut dyn StrategyContext) {}
}

let execution = PaperBroker::new(AccountType::Paper, 100_000.0, 1);
let data = YahooFinanceDataFeed::new();
let broker = UnifiedBroker::new_backtest(execution, data);

let timeframe = TimeFrame::new(1, TimeFrameUnit::Day);
let strategy = BlankStrategy;

let mut state = StrategyState::new(
    "blank-strategy".to_string(),
    "1.0.0".to_string(),
    strategy,
    broker,
    StrategyMode::Backtest,
    timeframe.clone(),
);

let start = Utc::now() - Duration::days(30);
let end = Utc::now();

let results = state.run_backtest(start, end, timeframe).await?;
results.print_metrics();

Este bloque inicial muestra el recorrido completo más sencillo: definir una estrategia, conectar un bróker simulado y una fuente de datos, ejecutar el backtest e inspeccionar las métricas resultantes. La llamada a add_events registra un marco temporal adicional de contexto; el marco temporal principal de la estrategia sigue ejecutándose automáticamente.

Generar un insight

Normalmente creas un insight dentro de un modelo alfa o de generate_insights() y después dejas que el pipeline de insights lo dimensione, añada controles de riesgo y lo envíe.

use aq_engine::core::broker::types::OrderSide;
use aq_engine::core::insight::{types::StrategyType, Insight};

fn generate_insights(&mut self, ctx: &mut dyn StrategyContext, symbol: &str) {
    let mut insight = Insight::new(
        OrderSide::Buy,
        symbol.to_string(),
        StrategyType::Testing,
        ctx.timeframe().clone(),
        80,
        None,
    );

    insight
        .set_limit_price(Some(200.0))
        .set_take_profit_levels(Some(vec![206.0]))
        .set_stop_loss(Some(197.5))
        .set_period_unfilled(Some(5))
        .set_period_till_tp(Some(12));

    ctx.add_insight(insight);
}

Para conocer el modelo completo de insights, consulta Insights. Para dimensionamiento, validación y envío, consulta Pipes de insights.