investfly-sdk 1.6__py3-none-any.whl → 1.8__py3-none-any.whl

investfly/models/Indicator.py

@@ -27,6 +27,78 @@ class ParamType(str, Enum):
         return self.value
 
 
+class INDICATORS(str, Enum):
+    """
+    Enum listing all supported technical indicators in the system.
+    These indicators can be used in trading strategies for technical analysis.
+    """
+    
+    SMA = 'SMA'               # Simple Moving Average
+    EMA = 'EMA'               # Exponential Moving Average
+    TEMA = 'TEMA'             # Triple Exponential Moving Average
+    DEMA = 'DEMA'             # Double Exponential Moving Average
+    KAMA = 'KAMA'             # Kaufman Adaptive Moving Average
+    MAMA = 'MAMA'             # MESA Adaptive Moving Average
+    FAMA = 'FAMA'             # Following Adaptive Moving Average
+    UPPERBBAND = 'UPPERBBAND' # Upper Bollinger Band
+    LOWERBBAND = 'LOWERBBAND' # Lower Bollinger Band
+    ICHIMOKU = 'ICHIMOKU'     # Ichimoku Conversion Line
+    KELTNER = 'KELTNER'       # Keltner Channel Middle Line
+    MACD = 'MACD'             # Moving Average Convergence/Divergence
+    MACDS = 'MACDS'           # MACD Signal Line
+    RSI = 'RSI'               # Relative Strength Index
+    ROC = 'ROC'               # Rate of Change
+    CCI = 'CCI'               # Commodity Channel Index
+    ADX = 'ADX'               # Average Directional Index
+    ADXR = 'ADXR'             # Average Directional Movement Index Rating
+    AROONOSC = 'AROONOSC'     # Aroon Oscillator
+    AROON = 'AROON'           # Aroon Up
+    AROONDOWN = 'AROONDOWN'   # Aroon Down
+    MFI = 'MFI'               # Money Flow Index
+    CMO = 'CMO'               # Chande Momentum Oscillator
+    STOCH = 'STOCH'           # Stochastic
+    STOCHF = 'STOCHF'         # Stochastic Fast
+    STOCHRSI = 'STOCHRSI'     # Stochastic RSI
+    APO = 'APO'               # Absolute Price Oscillator
+    PPO = 'PPO'               # Percentage Price Oscillator
+    MINUS_DI = 'MINUS_DI'     # Minus Directional Indicator
+    PLUS_DI = 'PLUS_DI'       # Plus Directional Indicator
+    DX = 'DX'                 # Directional Movement Index
+    TRIX = 'TRIX'             # Triple Exponential Moving Average Oscillator
+    BOP = 'BOP'               # Balance of Power
+    OBV = 'OBV'               # On Balance Volume
+    CMF = 'CMF'               # Chaikin Money Flow
+    AVGVOL = 'AVGVOL'         # Average Volume
+    ATR = 'ATR'               # Average True Range
+    AVGPRICE = 'AVGPRICE'     # Average Price
+    MEDPRICE = 'MEDPRICE'     # Median Price
+    TYPPRICE = 'TYPPRICE'     # Typical Price
+    WCLPRICE = 'WCLPRICE'     # Weighted Close Price
+    BARPRICE = 'BARPRICE'     # Bar Price (custom)
+    MAX = 'MAX'               # Maximum value over period
+    MIN = 'MIN'               # Minimum value over period
+    CDLENGULFING = 'CDLENGULFING' # Engulfing Pattern
+    CDLDOJI = 'CDLDOJI'       # Doji
+    CDLHAMMER = 'CDLHAMMER'   # Hammer
+    CDLMORNINGSTAR = 'CDLMORNINGSTAR' # Morning Star
+    CDLEVENINGSTAR = 'CDLEVENINGSTAR' # Evening Star
+    CDLHARAMI = 'CDLHARAMI'   # Harami Pattern
+    CDLSHOOTINGSTAR = 'CDLSHOOTINGSTAR' # Shooting Star
+    CDL3BLACKCROWS = 'CDL3BLACKCROWS' # Three Black Crows
+    CDL3WHITESOLDIERS = 'CDL3WHITESOLDIERS' # Three White Soldiers
+    CDLMARUBOZU = 'CDLMARUBOZU' # Marubozu
+    PSAR = 'PSAR'             # Parabolic SAR
+    WILLIAMR = 'WILLIAMR'     # Williams' %R
+    VWAP = 'VWAP'             # Volume Weighted Average Price
+    RVOL = 'RVOL'             # Relative Volume
+    
+    def __str__(self):
+        return self.value
+    
+    def __repr__(self):
+        return self.value
+
+
 @dataclass
 class IndicatorParamSpec:
 
@@ -46,7 +118,7 @@ class IndicatorParamSpec:
     """ Valid value options (if any). If specified, then in the UI, this parameter renders as a dropdown select list.
     If left as None, parameter renders and freeform input text field. """
 
-    PERIOD_VALUES: ClassVar[List[int]] = [2, 3, 4, 5, 8, 9, 10, 12, 14, 15, 20, 26, 30, 40, 50, 60, 70, 80, 90, 100, 120, 130, 140, 150, 180, 200, 250, 300]
+    PERIOD_VALUES: ClassVar[List[int]] = [2, 3, 4, 5, 6, 7, 8,9, 10, 12, 14, 15, 20, 24, 26, 30, 40, 50, 60, 70, 80, 90, 100, 120, 130, 140, 150, 180, 200, 250, 300]
 
     def toDict(self) -> Dict[str, Any]:
         d = self.__dict__.copy()

investfly/models/MarketData.py

@@ -23,6 +23,8 @@ class SecurityType(str, Enum):
 
     STOCK = "STOCK"
     ETF = "ETF"
+    CRYPTO = "CRYPTO"
+    FOREX = "FOREX"
 
     def __str__(self):
         return self.value
@@ -65,21 +67,22 @@ class Quote:
     lastPrice: float
     prevClose: float| None = None
     todayChange: float | None = None
-    todayChangePercent: float | None = None
+    todayChangePct: float | None = None
     dayOpen: float | None = None
     dayHigh: float | None = None
     dayLow: float | None = None
-    dayVolume: int | None = None
+    volume: int | None = None
 
     @staticmethod
     def fromDict(jsonDict: Dict[str, Any]) -> Quote:
         quote = Quote(jsonDict["symbol"], parseDatetime(jsonDict["date"]), jsonDict["lastPrice"])
         quote.prevClose = jsonDict.get('prevClose')
         quote.todayChange = jsonDict.get("todayChange")
-        quote.todayChangePercent = jsonDict.get('todayChangePercent')
+        quote.todayChangePct = jsonDict.get('todayChangePct')
         quote.dayOpen = jsonDict.get('dayOpen')
         quote.dayHigh = jsonDict.get('dayHigh')
         quote.dayLow = jsonDict.get('dayLow')
+        quote.volume = jsonDict.get('volume')
         return quote
 
     def toDict(self) -> Dict[str, Any]:
@@ -111,27 +114,31 @@ class Quote:
                 raise Exception("DAY_CHANGE not available in Quote")
             return DatedValue(self.date, self.todayChange)
         elif quoteField == QuoteField.DAY_CHANGE_PCT:
-            if self.todayChangePercent is None:
+            if self.todayChangePct is None:
                 raise Exception("DAY_CHANGE_PCT value not available in Quote")
-            return DatedValue(self.date, self.todayChangePercent)
+            return DatedValue(self.date, self.todayChangePct)
         elif quoteField == QuoteField.DAY_VOLUME:
-            if self.dayVolume is None:
+            if self.volume is None:
                 raise Exception("DAY_VOLUME not available in Quote")
-            return DatedValue(self.date, self.dayVolume)
+            return DatedValue(self.date, self.volume)
+        elif quoteField == QuoteField.DAY_CHANGE_OPEN:
+            if self.dayOpen is None or self.lastPrice is None:
+                raise Exception("DAY_CHANGE_OPEN not available in Quote")
+            return DatedValue(self.date, self.lastPrice - self.dayOpen)
         else:
             raise Exception("Invalid Quote Indicator ID: " + quoteField)
 
     def toEODBar(self) -> Bar:
-        bar = Bar()
-        bar['symbol'] = self.symbol
-        bar['barinterval'] = BarInterval.ONE_DAY
-        bar['date'] = self.date.replace(second=0, microsecond=0)
-        bar['open'] = cast(float, self.dayOpen)
-        bar['high'] = cast(float, self.dayHigh)
-        bar['low'] = cast(float, self.dayLow)
-        bar['close'] = cast(float, self.lastPrice)
-        bar['volume'] = cast(int, self.dayVolume)
-        return bar
+        return Bar(
+            symbol=self.symbol,
+            barinterval=BarInterval.ONE_DAY,
+            date=self.date.replace(second=0, microsecond=0),
+            open=cast(float, self.dayOpen),
+            high=cast(float, self.dayHigh),
+            low=cast(float, self.dayLow),
+            close=cast(float, self.lastPrice),
+            volume=cast(int, self.volume)
+        )
 
 
 class BarInterval(str, Enum):
@@ -167,8 +174,7 @@ Bar = TypedDict("Bar", {"symbol": str,
                         "high": float,
                         "low": float,
                         "volume": int
-                        },
-                total=False)
+                        })
 
 @dataclass
 class StockNews:

investfly/models/ModelUtils.py

@@ -1,23 +1,26 @@
 from datetime import datetime
-import pytz
-
+from zoneinfo import ZoneInfo
 
 class ModelUtils:
 
     # In Java, using Date includes timezone offset in JSON whereas using LocalDateTime does not
 
-    est_tz = pytz.timezone('America/New_York')
+    est_zone = ZoneInfo("US/Eastern")
+
+    @staticmethod
+    def convertoToEst(dt: datetime) -> datetime:
+        return dt.astimezone(ModelUtils.est_zone)
 
     @staticmethod
     def localizeDateTime(dt: datetime) -> datetime:
-        return ModelUtils.est_tz.localize(dt)
+        return dt.replace(tzinfo=ModelUtils.est_zone)
 
 
     @staticmethod
     def parseDatetime(date_str: str) -> datetime:
         dateFormat = '%Y-%m-%dT%H:%M:%S.%f' if "." in date_str else '%Y-%m-%dT%H:%M:%S'
         dt = datetime.strptime(date_str, dateFormat)
-        dt = dt.astimezone(ModelUtils.est_tz)
+        dt = dt.astimezone(ModelUtils.est_zone)
         return dt
 
     @staticmethod
@@ -27,7 +30,7 @@ class ModelUtils:
     @staticmethod
     def parseZonedDatetime(date_str: str) -> datetime:
         dt = datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S.%f%z')
-        dt = dt.astimezone(ModelUtils.est_tz)
+        dt = dt.astimezone(ModelUtils.est_zone)
         return dt
 
     @staticmethod

investfly/models/PortfolioModels.py

@@ -52,10 +52,12 @@ class Broker(str, Enum):
 
     """Broker Type Enum"""
 
-    INVESTFLY = "INVESTFLY"
     TRADIER = "TRADIER"
-    TDAMERITRADE = "TDAMERITRADE"
+    INVESTFLY = "INVESTFLY"
+    TASTYTRADE = "TASTYTRADE"
+    ALPACA = "ALPACA"
     BACKTEST = "BACKTEST"
+    OANDA = "OANDA"
 
     def __str__(self):
         return self.value
@@ -70,7 +72,7 @@ class TradeOrder:
     security: Security
     tradeType: TradeType
     orderType: OrderType = OrderType.MARKET_ORDER
-    quantity: int | None = None
+    quantity: float | None = None
     maxAmount: float | None = None
     limitPrice: float | None = None # If left empty, will use latest quote as limit price
 
@@ -133,7 +135,7 @@ class CompletedTrade:
     security: Security
     date: datetime
     price: float
-    quantity: int
+    quantity: float
     tradeType: TradeType
 
     @staticmethod
@@ -151,7 +153,7 @@ class ClosedPosition:
     closeDate: datetime
     openPrice: float
     closePrice: float
-    quantity: int
+    quantity: float
     profitLoss: float|None = None
     percentChange: float| None = None
 
@@ -186,7 +188,7 @@ class OpenPosition:
     security: Security
     position: PositionType
     avgPrice: float
-    quantity: int
+    quantity: float
     purchaseDate: datetime
     currentPrice: float | None = None
     currentValue: float | None = None

investfly/models/SecurityUniverseSelector.py

@@ -5,19 +5,49 @@ from enum import Enum
 from numbers import Number
 from typing import List, Dict, Any, cast
 
-from investfly.models.MarketData import SecurityType
+from investfly.models.MarketData import SecurityType, Security
 from investfly.models.MarketDataIds import FinancialField
 
 
 class StandardSymbolsList(str, Enum):
+    # Stock lists
     SP_100 = "SP_100"
     SP_500 = "SP_500"
     NASDAQ_100 = "NASDAQ_100"
     NASDAQ_COMPOSITE = "NASDAQ_COMPOSITE"
     RUSSELL_1000 = "RUSSELL_1000"
+    RUSSELL_2000 = "RUSSELL_2000"
     DOW_JONES_INDUSTRIALS = "DOW_JONES_INDUSTRIALS"
+    
+    # General lists
+    STOCKS = "STOCKS"
     ETFS = "ETFS"
 
+    ALL_CRYPTO = "ALL_CRYPTO"
+    USD_CRYPTO = "USD_CRYPTO"
+
+    # Forex lists
+    ALL_FOREX = "ALL_FOREX"
+
+    @property
+    def securityType(self) -> SecurityType:
+        # Map each enum value to its corresponding security type
+        security_type_map = {
+            "SP_100": SecurityType.STOCK,
+            "SP_500": SecurityType.STOCK,
+            "NASDAQ_100": SecurityType.STOCK,
+            "NASDAQ_COMPOSITE": SecurityType.STOCK,
+            "RUSSELL_1000": SecurityType.STOCK,
+            "RUSSELL_2000": SecurityType.STOCK,
+            "DOW_JONES_INDUSTRIALS": SecurityType.STOCK,
+            "STOCKS": SecurityType.STOCK,
+            "ETFS": SecurityType.STOCK,
+            "ALL_CRYPTO": SecurityType.CRYPTO,
+            "USD_CRYPTO": SecurityType.CRYPTO,
+            "ALL_FOREX": SecurityType.FOREX
+        }
+        return security_type_map[self.value]
+
     def __str__(self):
         return self.value
 
@@ -26,8 +56,7 @@ class StandardSymbolsList(str, Enum):
 
 
 class CustomSecurityList:
-    def __init__(self, securityType: SecurityType):
-        self.securityType = securityType
+    def __init__(self):
         self.symbols: List[str] = []
 
     def addSymbol(self, symbol: str) -> None:
@@ -35,7 +64,7 @@ class CustomSecurityList:
 
     @staticmethod
     def fromJson(json_dict: Dict[str, Any]) -> CustomSecurityList:
-        securityList = CustomSecurityList(SecurityType(json_dict['securityType']))
+        securityList = CustomSecurityList()
         securityList.symbols = json_dict['symbols']
         return securityList
 
@@ -43,8 +72,6 @@ class CustomSecurityList:
         return self.__dict__.copy()
 
     def validate(self) -> None:
-        if self.securityType is None:
-            raise Exception("CustomSecurityList.securityType is required")
         if len(self.symbols) == 0:
             raise Exception("CustomSecurityList.symbols: At least one symbol is required")
 
@@ -133,6 +160,10 @@ class SecurityUniverseSelector:
     You can pick one of the standard list (e.g SP100) that we provide, provide your own list with comma separated symbols list,
     or provide a query based on fundamental metrics like MarketCap, PE Ratio etc.
     """
+
+    securityType: SecurityType
+    """The security type for the universe selector"""
+
     universeType: SecurityUniverseType
     """The approach used to specify the stocks. Depending on the universeType, one of the attribute below must be specified"""
 
@@ -142,16 +173,35 @@ class SecurityUniverseSelector:
     customList: CustomSecurityList | None = None
     financialQuery: FinancialQuery | None = None
 
+    @staticmethod
+    def getValidSymbolLists(securityType: SecurityType) -> List[StandardSymbolsList]:
+        if securityType == SecurityType.CRYPTO:
+            return [StandardSymbolsList.USD_CRYPTO]
+        elif securityType == SecurityType.FOREX:
+            return [StandardSymbolsList.ALL_FOREX]
+        else:
+            # For STOCK and other types, return only STOCK security type lists except STOCKS
+            return [symbol_list for symbol_list in StandardSymbolsList 
+                    if symbol_list.securityType == SecurityType.STOCK and symbol_list != StandardSymbolsList.STOCKS]
+
     @staticmethod
     def fromDict(json_dict: Dict[str, Any]) -> SecurityUniverseSelector:
-        scopeType = SecurityUniverseType[json_dict['universeType']]
-        standardList = StandardSymbolsList[json_dict['standardList']] if 'standardList' in json_dict else None
+        securityType = SecurityType[json_dict['securityType']]
+        universeType = SecurityUniverseType[json_dict['universeType']]
+        standardList = None
+        if 'standardList' in json_dict:
+            list_name = json_dict['standardList']
+            standardList = StandardSymbolsList(list_name)
         customList = CustomSecurityList.fromJson(json_dict['customList']) if 'customList' in json_dict else None
         fundamentalQuery = FinancialQuery.fromDict(json_dict['financialQuery']) if 'financialQuery' in json_dict else None
-        return SecurityUniverseSelector(scopeType, standardList, customList,  cast(FinancialQuery, fundamentalQuery))
+        
+        return SecurityUniverseSelector(securityType, universeType, standardList, customList, cast(FinancialQuery, fundamentalQuery))
 
     def toDict(self) -> Dict[str, Any]:
-        jsonDict: Dict[str, Any] = {'universeType': self.universeType.value}
+        jsonDict: Dict[str, Any] = {
+            'securityType': self.securityType.value,
+            'universeType': self.universeType.value
+        }
         if self.standardList is not None:
             jsonDict["standardList"] = self.standardList.value
         if self.customList is not None:
@@ -163,48 +213,74 @@ class SecurityUniverseSelector:
     @staticmethod
     def singleStock(symbol: str) -> SecurityUniverseSelector:
         scopeType = SecurityUniverseType.CUSTOM_LIST
-        customList = CustomSecurityList(SecurityType.STOCK)
+        customList = CustomSecurityList()
         customList.addSymbol(symbol)
-        return SecurityUniverseSelector(scopeType, customList=customList)
+        return SecurityUniverseSelector(SecurityType.STOCK, scopeType, customList=customList)
 
     @staticmethod
-    def fromStockSymbols(symbols: List[str]) -> SecurityUniverseSelector:
+    def fromSecurity(security: Security) -> SecurityUniverseSelector:
         scopeType = SecurityUniverseType.CUSTOM_LIST
-        customList = CustomSecurityList(SecurityType.STOCK)
+        customList = CustomSecurityList()
+        customList.addSymbol(security.symbol)
+        return SecurityUniverseSelector(security.securityType, scopeType, customList=customList)
+
+    @staticmethod
+    def fromSymbols(securityType: SecurityType, symbols: List[str]) -> SecurityUniverseSelector:
+        scopeType = SecurityUniverseType.CUSTOM_LIST
+        customList = CustomSecurityList()
         customList.symbols = symbols
-        return SecurityUniverseSelector(scopeType, customList=customList)
+        return SecurityUniverseSelector(SecurityType.STOCK, scopeType, customList=customList)
 
     @staticmethod
     def fromStandardList(standardListName: StandardSymbolsList) -> SecurityUniverseSelector:
-        universeType = SecurityUniverseType.STANDARD_LIST
-        return SecurityUniverseSelector(universeType, standardList=standardListName)
+        return SecurityUniverseSelector(standardListName.securityType, SecurityUniverseType.STANDARD_LIST, standardList=standardListName)
 
     @staticmethod
     def fromFinancialQuery(financialQuery: FinancialQuery) -> SecurityUniverseSelector:
         universeType = SecurityUniverseType.FUNDAMENTAL_QUERY
-        return SecurityUniverseSelector(universeType, financialQuery=financialQuery)
+        return SecurityUniverseSelector(SecurityType.STOCK, universeType, financialQuery=financialQuery)
 
-    def getSecurityType(self) -> SecurityType:
-        if self.universeType == SecurityUniverseType.STANDARD_LIST:
-            return SecurityType.ETF if self.standardList == StandardSymbolsList.ETFS else SecurityType.STOCK
-        elif self.universeType == SecurityUniverseType.CUSTOM_LIST:
-            return cast(CustomSecurityList, self.customList).securityType
-        else:
-            return SecurityType.STOCK
 
     def validate(self) -> None:
+        # Note - Python should have exact code to validate SecurityUniverseSelector because custom strategy also return SecurityUniverseSelector
+        # Technically, we could avoid duplicate validation here, but we keep it here to avoid sending network call to Python server to fail fast
+
+        # Validate securityType is not null
+        if self.securityType is None:
+            raise Exception("SecurityUniverseSelector.securityType is required")
+        
+        # Validate securityType is one of STOCK, CRYPTO, or FOREX
+        if self.securityType not in (SecurityType.STOCK, SecurityType.CRYPTO, SecurityType.FOREX):
+            raise Exception(f"SecurityUniverseSelector.securityType must be one of STOCK, CRYPTO, or FOREX, not {self.securityType}")
+        
+        # Validate universeType is not null
         if self.universeType is None:
             raise Exception("SecurityUniverseSelector.universeType is required")
+        
+        # For CRYPTO, ETF, CURRENCY - only STANDARD_LIST and CUSTOM_LIST are valid
+        if self.securityType != SecurityType.STOCK and self.universeType == SecurityUniverseType.FUNDAMENTAL_QUERY:
+            raise Exception(f"FUNDAMENTAL_QUERY universe type is only valid for SecurityType.STOCK, not for {self.securityType}")
+        
         if self.universeType == SecurityUniverseType.STANDARD_LIST:
             if self.standardList is None:
                 raise Exception("SecurityUniverseSelector.standardList is required for StandardList UniverseType")
+            
+            # If using STANDARD_LIST, StandardSymbolsList.security_type must match securityType
+            if self.standardList.securityType != self.securityType:
+                raise Exception(f"StandardSymbolsList security type ({self.standardList.securityType}) must match SecurityUniverseSelector security type ({self.securityType})")
+            
+            # Validate that the standardList is allowed for the given securityType
+            validLists = self.getValidSymbolLists(self.securityType)
+            if self.standardList not in validLists:
+                raise Exception(f"StandardSymbolsList ({self.standardList}) is not valid for SecurityType ({self.securityType}). Valid lists are: {validLists}")
+                
         elif self.universeType == SecurityUniverseType.CUSTOM_LIST:
             if self.customList is None:
                 raise Exception("SecurityUniverseSelector.customList is required for CustomList UniverseType")
             self.customList.validate()
+            
         elif self.universeType == SecurityUniverseType.FUNDAMENTAL_QUERY:
             if self.financialQuery is None:
-                raise Exception(
-                    "SecurityUniverseSelector.fundamentalQuery is required for FUNDAMENTAL_QUERY UniverseType")
+                raise Exception("SecurityUniverseSelector.fundamentalQuery is required for FUNDAMENTAL_QUERY UniverseType")
             self.financialQuery.validate()
 

investfly/models/TradingStrategy.py

@@ -1,7 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import List, Any, Dict
 
-from investfly.models.MarketData import Security
+from investfly.models.MarketData import SecurityType, Security
 from investfly.models.SecurityUniverseSelector import SecurityUniverseSelector
 from investfly.models.StrategyModels import TradeSignal, StandardCloseCriteria
 from investfly.models.PortfolioModels import TradeOrder, OpenPosition, Portfolio, PositionType
@@ -17,6 +17,10 @@ class TradingStrategy(ABC):
         self.state: Dict[str, int | float | bool] = {}
         """The persisted state of the strategy. """
 
+    def getSecurityType(self) -> SecurityType:
+        return self.getSecurityUniverseSelector().securityType
+        
+
     @abstractmethod
     def getSecurityUniverseSelector(self) -> SecurityUniverseSelector:
         """

investfly/models/__init__.py

@@ -7,7 +7,7 @@ The main class for defining custom technical indicator is `investfly.models.Indi
 """
 
 from investfly.models.CommonModels import DatedValue, TimeUnit, TimeDelta, Session
-from investfly.models.Indicator import ParamType, IndicatorParamSpec, IndicatorValueType, IndicatorSpec, Indicator
+from investfly.models.Indicator import ParamType, IndicatorParamSpec, IndicatorValueType, IndicatorSpec, Indicator, INDICATORS
 from investfly.models.MarketData import SecurityType, Security, Quote, BarInterval, Bar
 from investfly.models.MarketDataIds import QuoteField, FinancialField, StandardIndicatorId
 from investfly.models.PortfolioModels import PositionType, TradeType, Broker, TradeOrder, OrderStatus, PendingOrder, Balances, CompletedTrade, OpenPosition, ClosedPosition, Portfolio, PortfolioPerformance
@@ -15,4 +15,5 @@ from investfly.models.SecurityUniverseSelector import StandardSymbolsList, Custo
 from investfly.models.StrategyModels import DataParams, ScheduleInterval, Schedule, TradeSignal, StandardCloseCriteria, PortfolioSecurityAllocator, BacktestStatus
 from investfly.models.TradingStrategy import TradingStrategy
 from investfly.models.SecurityFilterModels import DataType, DataParam, DataSource
+from investfly.models.ModelUtils import ModelUtils
 

investfly/samples/strategies/MacdTrendFollowingStrategy.py

@@ -0,0 +1,98 @@
+from typing import Dict, Any, List
+
+from investfly.models import *
+from investfly.utils import PercentBasedPortfolioAllocator
+
+
+class MacdTrendFollowingStrategy(TradingStrategy):
+    """
+    A trend following strategy based on the MACD (Moving Average Convergence Divergence) indicator.
+    
+    This strategy:
+    1. Uses the MACD indicator to identify trend momentum
+    2. Generates buy signals when the MACD line crosses above the signal line (bullish momentum)
+    3. Includes risk management with target profit, stop loss, and time-based exit criteria
+    4. Allocates portfolio to the top 5 stocks showing the strongest signals
+    
+    Note: This strategy operates on daily bars, so evaluateOpenTradeCondition is called
+    at most once per day when a new daily bar is available.
+    """
+
+    def getSecurityUniverseSelector(self) -> SecurityUniverseSelector:
+        """
+        Select the universe of securities to trade.
+        This strategy uses the S&P 100 stocks.
+        """
+        return SecurityUniverseSelector.fromStandardList(StandardSymbolsList.SP_100)
+
+    @DataParams({
+        # MACD is typically calculated with 12, 26, and 9 as the standard parameters
+        # We request the MACD line and the signal line (MACDS)
+        "macd": {"datatype": DataType.INDICATOR, "indicator": INDICATORS.MACD, "barinterval": BarInterval.ONE_DAY, "count": 2},
+        "macds": {"datatype": DataType.INDICATOR, "indicator": INDICATORS.MACDS, "barinterval": BarInterval.ONE_DAY, "count": 2},
+        # Request the latest daily bar to get the closing price for signal strength calculation
+        "daily_bar": {"datatype": DataType.BARS, "barinterval": BarInterval.ONE_DAY, "count": 1}
+    })
+    def evaluateOpenTradeCondition(self, security: Security, data: Dict[str, Any]) -> TradeSignal | None:
+        """
+        Generate a buy signal when the MACD line crosses above the signal line,
+        indicating increasing bullish momentum.
+        
+        The signal strength is calculated based on the magnitude of the difference
+        between MACD and signal line relative to the stock's closing price from the latest daily bar.
+        
+        This method is called at most once per day when a new daily bar is available.
+        """
+        macd = data["macd"]
+        macds = data["macds"]
+        daily_bar = data["daily_bar"][-1]  # Get the latest daily bar
+        
+        # Check for MACD line crossing above the signal line (bullish crossover)
+        if macd[-1].value > macds[-1].value and macd[-2].value <= macds[-2].value:
+            # Get the closing price from the latest daily bar
+            closing_price = daily_bar.close
+            
+            # Calculate signal strength as a percentage of the difference relative to price
+            # This helps prioritize stronger signals when allocating portfolio
+            macd_diff = abs(macd[-1].value - macds[-1].value)
+            
+            # Calculate signal strength based on:
+            # 1. The magnitude of the MACD crossover (larger difference = stronger signal)
+            # 2. The relative size of the difference compared to the stock price
+            signal_strength = (macd_diff / closing_price) * 100
+            
+            # Add a component based on the rate of change of MACD to further strengthen the signal
+            macd_change_rate = abs(macd[-1].value - macd[-2].value) / abs(macd[-2].value) if macd[-2].value != 0 else 0
+            signal_strength = signal_strength * (1 + macd_change_rate)
+            
+            # Return a long position signal with the calculated strength
+            return TradeSignal(security, PositionType.LONG, signal_strength)
+        
+        return None
+
+    def getStandardCloseCondition(self) -> StandardCloseCriteria:
+        """
+        Define standard exit criteria for positions:
+        - Take profit at 5% gain
+        - Stop loss at 3% loss
+        - Time-based exit after 10 trading days (to prevent holding positions too long)
+        """
+        return StandardCloseCriteria(
+            targetProfit=5,           # Take profit at 5% gain
+            stopLoss=-3,              # Stop loss at 3% loss
+            trailingStop=None,        # No trailing stop for this strategy
+            timeOut=TimeDelta(10, TimeUnit.DAYS)  # Exit after 10 trading days
+        )
+
+    def processOpenTradeSignals(self, portfolio: Portfolio, tradeSignals: List[TradeSignal]) -> List[TradeOrder]:
+        """
+        Process the trade signals and allocate the portfolio.
+        This strategy allocates to the top 5 stocks with the strongest signals.
+        """
+        # Sort trade signals by strength in descending order
+        sorted_signals = sorted(tradeSignals, key=lambda signal: signal.strength if signal.strength is not None else 0, reverse=True)
+        
+        # Use the PercentBasedPortfolioAllocator to allocate the portfolio
+        # Allocate to the top 5 stocks with equal weight (20% each)
+        portfolioAllocator = PercentBasedPortfolioAllocator(5)
+        return portfolioAllocator.allocatePortfolio(portfolio, sorted_signals)