sentio/strategy/alpaca/ppo_20250709/strategy.go

package main

import (
	"git.beejay.kim/Gshopper/sentio"
	"git.beejay.kim/Gshopper/sentio/util"
	"time"
)

var Strategy = qqq{}

type qqq struct{}

func (strategy qqq) Name() string {
	return "Alpaca: Hybrid [TQQQ : SQQQ]"
}

func (strategy qqq) Model() string {
	return "ppo_20250709"
}

func (strategy qqq) MarketId() string {
	return "alpaca"
}

func (strategy qqq) Interval() uint8 {
	return 1
}

func (strategy qqq) EnableStopLoss() bool {
	return false
}

func (strategy qqq) PositionSymbols() map[sentio.Side]string {
	return map[sentio.Side]string{
		sentio.BASE:  "QQQ",
		sentio.LONG:  "TQQQ",
		sentio.SHORT: "SQQQ",
	}
}

func (strategy qqq) MaxTradeDuration() time.Duration {
	return time.Duration(strategy.Interval()) * time.Minute * 5
}

func (strategy qqq) Handle(turn *sentio.Turn, market sentio.Market, rs sentio.RiskManager) error {
	if market == nil || turn == nil {
		return nil
	}

	var (
		now     = market.Clock().Now()
		symbols = util.Symbols(strategy)
		quotes  map[string]sentio.Quote
		orders  []sentio.Order
		err     error
	)

	// skip too early orders or late orders
	if (now.Hour() == 9 && now.Minute() < 31) || now.Hour() > 15 {
		return nil
	}

	// close all orders before market close
	if now.Hour() == 15 && now.Minute() > 50 {
		return util.CloseAllOrders(market, strategy)
	}

	if quotes, err = market.Quotes(); err != nil {
		return err
	}

	// retrieve running orders
	if orders, err = market.Orders(sentio.OrderListCriteria{
		Status:  util.ToPtr("open"),
		Symbols: symbols,
	}); err != nil {
		return err
	}

	// update StopLosses or close running orders
	var hasClosedOrders = false

	for i := range orders {
		shouldClose := false

		if orders[i].GetSymbol() == strategy.PositionSymbols()[sentio.LONG] && sentio.Action_SELL == turn.Action {
			shouldClose = true
		}

		if orders[i].GetSymbol() == strategy.PositionSymbols()[sentio.BASE] &&
			sentio.LONG == orders[i].Intent() && sentio.Action_SELL == turn.Action {
			shouldClose = true
		}

		if orders[i].GetSymbol() == strategy.PositionSymbols()[sentio.SHORT] && sentio.Action_BUY == turn.Action {
			shouldClose = true
		}

		if orders[i].GetSymbol() == strategy.PositionSymbols()[sentio.BASE] &&
			sentio.SHORT == orders[i].Intent() && sentio.Action_BUY == turn.Action {
			shouldClose = true
		}

		if shouldClose {
			if _, err = market.CloseOrder(orders[i], nil); err != nil {
				return err
			}

			hasClosedOrders = true
			continue
		}

		if orders[i].GetCreatedAt().Round(time.Minute).Add(strategy.MaxTradeDuration()).Before(time.Now()) {
			if _, err = market.CloseOrder(orders[i], nil); err != nil {
				return err
			}

			hasClosedOrders = true
			continue
		}

		opts := sentio.OrderUpdateOptions{
			TakeProfit:     rs.TakeProfit(orders[i].GetSymbol(), quotes[orders[i].GetSymbol()].BidPrice),
			StopLoss:       rs.StopLoss(orders[i].GetSymbol(), quotes[orders[i].GetSymbol()].BidPrice),
			EnableStopLoss: strategy.EnableStopLoss(),
		}

		if err = market.UpdateOrder(orders[i].GetId(), opts); err != nil {
			return err
		}
	}

	// Prevent new orders if we just closed one
	if hasClosedOrders || len(orders) > 0 {
		return nil
	}

	// Prevent BUYs on closing market
	if now.Hour() == 15 && now.Minute() > 45 {
		return nil
	}

	var opts sentio.OrderCreateOptions
	if opts, err = util.NewOrder(market, strategy, turn.Action, quotes, rs); err != nil {
		return err
	}

	// Disable StopLoss
	if !strategy.EnableStopLoss() {
		opts.StopLoss = nil
	}

	return market.CreateOrder(opts)
}