investfly-sdk 1.0__py3-none-any.whl

investfly/models/SecurityFilterModels.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+import numbers
+from enum import Enum
+from typing import Dict, Any, cast
+
+from investfly.models.MarketData import BarInterval
+from investfly.models.MarketDataIds import QuoteField, FinancialField
+
+
+class DataSource(str, Enum):
+    BARS = "BARS"
+    FINANCIAL = "FINANCIAL"
+    QUOTE = "QUOTE"
+    NEWS = "NEWS"
+
+
+class DataType(str, Enum):
+    BARS = "BARS"
+    FINANCIAL = "FINANCIAL"
+    QUOTE = "QUOTE"
+    NEWS = "NEWS"
+
+    INDICATOR = "INDICATOR"
+    CONST = "CONST"
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+
+class ConstUnit(str, Enum):
+    K = "K"
+    M = "M"
+    B = "B"
+
+
+class DataParam(Dict[str, Any]):
+    SECURITY = "security"
+    FIELD = "field"
+    INDICATOR = "indicator"
+    DATATYPE = "datatype"
+    VALUE = "value"
+    UNIT = "unit"
+    BARINTERVAL = "barinterval"
+    LOOKBACK = "lookback"
+    COUNT = "count"
+
+    def setDataType(self, dataType: DataType) -> None:
+        self[DataParam.DATATYPE] = dataType
+
+    def getDataType(self) -> DataType:
+        return cast(DataType, self.get(DataParam.DATATYPE))
+
+    def getIndicatorId(self) -> str:
+        return cast(str, self.get(DataParam.INDICATOR))
+
+    def getBarInterval(self) -> BarInterval|None:
+        return self.get(DataParam.BARINTERVAL)
+
+    def getQuoteField(self) -> QuoteField | None:
+        return self.get(DataParam.FIELD)
+
+    def getFinancialField(self) -> FinancialField | None:
+        return self.get(DataParam.FIELD)
+
+    def getCount(self) -> int | None:
+        return self.get(DataParam.COUNT)
+
+    def getLookback(self) -> int | None:
+        return self.get(DataParam.LOOKBACK)
+
+    def getConstValue(self) -> int | float:
+        val = cast(int|float, self.get(DataParam.VALUE))
+        unit: ConstUnit|None = self.get(DataParam.UNIT)
+        if unit is None:
+            return val
+        elif unit == ConstUnit.K:
+            return val * 1000
+        elif unit == ConstUnit.M:
+            return val * 1000000
+        elif unit == ConstUnit.B:
+            return val * 1000000000
+        else:
+            raise Exception(f"Unknown unit {unit}")
+
+    def getSecurity(self) -> str | None:
+        return self.get(DataParam.SECURITY)
+
+    def validate(self) -> None:
+        dataType: DataType|None = self.get(DataParam.DATATYPE)
+        if dataType is None:
+            raise Exception("'datatype' attribute is required for all data parameters")
+        if not isinstance(dataType, DataType):
+            raise Exception(f"'datatype' must of of type Enum DataType")
+
+        if dataType == DataType.CONST:
+            value: numbers.Number|None = self.get(DataParam.VALUE)
+            unit: ConstUnit|None = self.get(DataParam.UNIT)
+            if value is None:
+                raise Exception("'value' attribute is required for CONST datatype")
+            if not isinstance(value, numbers.Number):
+                raise Exception("const value must be a number")
+            if unit is not None and not isinstance(unit, ConstUnit):
+                raise Exception("const unit must be of type ConstUnit")
+
+        elif dataType == DataType.QUOTE:
+            quoteField: QuoteField|None = self.get(DataParam.FIELD)
+            if quoteField is not None:
+                if not isinstance(quoteField, QuoteField):
+                    raise Exception("'field' attribute for 'Quote' datatype must be QuoteField")
+
+        elif dataType == DataType.FINANCIAL:
+            financialField: FinancialField|None = self.get(DataParam.FIELD)
+            if financialField is not None:
+                if not isinstance(financialField, FinancialField):
+                    raise Exception("'field' attribute for 'Quote' datatype must be FinancialField")
+
+        elif dataType == DataType.INDICATOR:
+            indicatorId: str|None = self.getIndicatorId()
+            if indicatorId is None:
+                raise Exception("'indicator' attribute is required for Indicator datatype")
+
+        elif dataType == DataType.BARS:
+            barPrice = self.get("price")
+            if barPrice is not None:
+                if barPrice not in ["open", "high", "low", "close", "volume"]:
+                    raise Exception("'price' attribute in BARS type must be on of [open, high, low, close, volume]")
+
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> DataParam:
+        dataParam = DataParam()
+        dataType: DataType = DataType[cast(str, json_dict.get(DataParam.DATATYPE))]
+        dataParam.setDataType(dataType)
+
+        for key in json_dict.keys():
+            value = json_dict[key]
+            if key == DataParam.DATATYPE:
+                continue
+            elif key == DataParam.BARINTERVAL:
+                dataParam[key] = BarInterval[value]
+            elif key == DataParam.FIELD:
+                if dataType == DataType.QUOTE:
+                    dataParam[key] = QuoteField[value]
+                elif dataType == DataType.FINANCIAL:
+                    dataParam[key] = FinancialField[value]
+                else:
+                    dataParam[key] = value
+            elif key == DataParam.INDICATOR:
+                # Since indicator can also be custom indicator, it cant be converted to StandardIndicatorId enum
+                dataParam[key] = value
+            elif key == DataParam.VALUE:
+                # json.loads should already have converted to int or float based on the value
+                dataParam[key] = value
+            elif key == DataParam.UNIT:
+                dataParam[key] = ConstUnit[value]
+            else:
+                dataParam[key] = value
+        return dataParam
+
+    def clone(self) -> DataParam:
+        dataParam: DataParam = DataParam()
+        for key in self.keys():
+            dataParam[key] = self.get(key)
+        return dataParam

investfly/models/SecurityUniverseSelector.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+from numbers import Number
+from typing import List, Dict, Any, cast
+
+from investfly.models.MarketData import SecurityType
+from investfly.models.MarketDataIds import FinancialField
+
+
+class StandardSymbolsList(str, Enum):
+    SP_100 = "SP_100"
+    SP_500 = "SP_500"
+    NASDAQ_100 = "NASDAQ_100"
+    NASDAQ_COMPOSITE = "NASDAQ_COMPOSITE"
+    RUSSELL_1000 = "RUSSELL_1000"
+    DOW_JONES_INDUSTRIALS = "DOW_JONES_INDUSTRIALS"
+    ETFS = "ETFS"
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+
+class CustomSecurityList:
+    def __init__(self, securityType: SecurityType):
+        self.securityType = securityType
+        self.symbols: List[str] = []
+
+    def addSymbol(self, symbol: str) -> None:
+        self.symbols.append(symbol)
+
+    @staticmethod
+    def fromJson(json_dict: Dict[str, Any]) -> CustomSecurityList:
+        securityList = CustomSecurityList(SecurityType(json_dict['securityType']))
+        securityList.symbols = json_dict['symbols']
+        return securityList
+
+    def toDict(self) -> Dict[str, Any]:
+        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")
+
+
+class SecurityUniverseType(str, Enum):
+    STANDARD_LIST = "STANDARD_LIST",
+    CUSTOM_LIST = "CUSTOM_LIST",
+    FUNDAMENTAL_QUERY = "FUNDAMENTAL_QUERY"
+
+
+class ComparisonOperator(str, Enum):
+    GREATER_THAN = ">"
+    LESS_THAN = "<"
+    GREATER_OR_EQUAL = ">="
+    LESS_OR_EQUAL = "<="
+    EQUAL_TO = "=="
+
+
+@dataclass
+class FinancialCondition:
+    financialField: FinancialField
+    operator: ComparisonOperator
+    value: str | FinancialField
+
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> FinancialCondition:
+        financialField = FinancialField[json_dict['financialField']]
+        operator = ComparisonOperator[json_dict['operator']]
+        valueFromJson = json_dict['value']
+        allFinancialFields = [cast(FinancialField, f).name for f in FinancialField]
+        if valueFromJson is allFinancialFields:
+            value = FinancialField[valueFromJson]
+        else:
+            value = valueFromJson
+
+        return FinancialCondition(financialField, operator, value)
+
+    def toDict(self) -> Dict[str, Any]:
+        return self.__dict__.copy()
+
+    def validate(self) -> None:
+        if not isinstance(self.financialField, FinancialField):
+            raise Exception("Left expression in financial query must be of type FinancialField")
+        if not isinstance(self.value, FinancialField) and not isinstance(self.value, str):
+            raise Exception("Right expression in financial query must of type Financial Field or string")
+        if isinstance(self.value, str):
+            # it must represent a number
+            valueStr = self.value
+            if valueStr.endswith("K") or valueStr.endswith("M") or valueStr.endswith("B"):
+                valueStr = valueStr[:-1]
+                if not valueStr.replace('.', '', 1).isdigit():
+                    raise Exception(f"Right expression offFinancial query must be a number or Financial Field. You provided: {self.value}")
+
+
+
+class FinancialQuery:
+    def __init__(self) -> None:
+        self.queryConditions: List[FinancialCondition] = []
+
+    def addCondition(self, condition: FinancialCondition) -> None:
+        self.queryConditions.append(condition)
+
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> FinancialQuery:
+        financialQuery = FinancialQuery()
+        conditionsList = json_dict['queryConditions']
+        for cond in conditionsList:
+            financialQuery.queryConditions.append(FinancialCondition.fromDict(cond))
+        return financialQuery
+
+    def toDict(self) -> Dict[str, Any]:
+        return {'queryConditions': [q.toDict() for q in self.queryConditions]}
+
+    def validate(self) -> None:
+        if len(self.queryConditions) == 0:
+            raise Exception("FinancialQuery must have at least one criteria")
+        for f in self.queryConditions:
+            f.validate()
+
+
+
+@dataclass
+class SecurityUniverseSelector:
+    universeType: SecurityUniverseType
+    standardList: StandardSymbolsList | None = None
+    customList: CustomSecurityList | None = None
+
+    financialQuery: FinancialQuery | None = None
+
+    @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
+        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))
+
+    def toDict(self) -> Dict[str, Any]:
+        jsonDict: Dict[str, Any] = {'universeType': self.universeType.value}
+        if self.standardList is not None:
+            jsonDict["standardList"] = self.standardList.value
+        if self.customList is not None:
+            jsonDict['customList'] = self.customList.toDict()
+        if self.financialQuery is not None:
+            jsonDict["financialQuery"] = self.financialQuery.toDict()
+        return jsonDict
+
+    @staticmethod
+    def singleStock(symbol: str) -> SecurityUniverseSelector:
+        scopeType = SecurityUniverseType.CUSTOM_LIST
+        customList = CustomSecurityList(SecurityType.STOCK)
+        customList.addSymbol(symbol)
+        return SecurityUniverseSelector(scopeType, customList=customList)
+
+    @staticmethod
+    def fromStockSymbols(symbols: List[str]) -> SecurityUniverseSelector:
+        scopeType = SecurityUniverseType.CUSTOM_LIST
+        customList = CustomSecurityList(SecurityType.STOCK)
+        customList.symbols = symbols
+        return SecurityUniverseSelector(scopeType, customList=customList)
+
+    @staticmethod
+    def fromStandardList(standardListName: StandardSymbolsList) -> SecurityUniverseSelector:
+        universeType = SecurityUniverseType.STANDARD_LIST
+        return SecurityUniverseSelector(universeType, standardList=standardListName)
+
+    @staticmethod
+    def fromFinancialQuery(financialQuery: FinancialQuery) -> SecurityUniverseSelector:
+        universeType = SecurityUniverseType.FUNDAMENTAL_QUERY
+        return SecurityUniverseSelector(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:
+        if self.universeType is None:
+            raise Exception("SecurityUniverseSelector.universeType is required")
+        if self.universeType == SecurityUniverseType.STANDARD_LIST:
+            if self.standardList is None:
+                raise Exception("SecurityUniverseSelector.standardList is required for StandardList UniverseType")
+        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")
+            self.financialQuery.validate()
+

investfly/models/StrategyModels.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import Dict, Any, List
+
+
+from investfly.models.CommonModels import TimeDelta
+from investfly.models.MarketData import Security
+from investfly.models.ModelUtils import ModelUtils
+from investfly.models.PortfolioModels import PositionType, Portfolio, TradeOrder
+from investfly.models.SecurityFilterModels import DataParam
+
+
+def DataParams(params: Dict[str, Dict[str, Any]]):
+    def decorator_func(func):
+        def wrapper_func(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        dataParams = {}
+        for key in params.keys():
+            paramDict = params[key]
+            dataParam = DataParam.fromDict(paramDict)
+            dataParams[key] = dataParam
+        return wrapper_func, dataParams
+
+    return decorator_func
+
+
+class ScheduleInterval(str, Enum):
+    DAILY_AFTER_MARKET_OPEN = "DAILY_AFTER_MARKET_OPEN"
+    DAILY_AFTER_MARKET_CLOSE = "DAILY_AFTER_MARKET_CLOSE"
+    HOURLY_DURING_MARKET_OPEN = "HOURLY_DURING_MARKET_OPEN"
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+
+def Schedule(param: ScheduleInterval | None):
+    def decorator_func(func):
+        def wrapper_func(*args, **kwargs):
+            return func(*args, **kwargs)
+
+        return wrapper_func, param
+
+    return decorator_func
+
+
+@dataclass
+class TradeSignal:
+    security: Security
+    position: PositionType
+    strength: int = 1
+    data: Dict[str, Any] | None = None  # Any other data besides strength that could be useful to generate TradeOrder
+
+
+@dataclass
+class StandardCloseCriteria:
+    targetProfit: float | None  # specify in scaled [0 - 100 range]
+    stopLoss: float | None  # specify as negative
+    trailingStop: float| None # specify as negative
+    timeOut: TimeDelta | None
+
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> StandardCloseCriteria:
+        return StandardCloseCriteria(
+            json_dict.get('targetProfit'),
+            json_dict.get('stopLoss'),
+            json_dict.get('trailingStop'),
+            TimeDelta.fromDict(json_dict['timeout']) if 'timeout' in json_dict else None
+        )
+
+    def toDict(self) -> Dict[str, Any]:
+        jsonDict = self.__dict__.copy()
+        if self.timeOut is not None:
+            jsonDict['timeout'] = self.timeOut.toDict()
+        return jsonDict
+
+
+
+class PortfolioSecurityAllocator(ABC):
+
+    @abstractmethod
+    def allocatePortfolio(self, portfolio: Portfolio, tradeSignals: List[TradeSignal]) -> List[TradeOrder]:
+        pass
+
+
+class LogLevel(str, Enum):
+    INFO = "INFO"
+    WARN = "WARN"
+    ERROR = "ERROR"
+
+@dataclass
+class DeploymentLog:
+    date: datetime
+    level: LogLevel
+    message: str
+
+    @staticmethod
+    def info(message: str) -> DeploymentLog:
+        return DeploymentLog(datetime.now(), LogLevel.INFO, message)
+
+    @staticmethod
+    def warn(message: str) -> DeploymentLog:
+        return DeploymentLog(datetime.now(), LogLevel.WARN, message)
+
+    @staticmethod
+    def error(message: str) -> DeploymentLog:
+        return DeploymentLog(datetime.now(), LogLevel.ERROR, message)
+
+    def toDict(self) -> Dict[str, Any]:
+        dict = self.__dict__.copy()
+        dict['date'] = ModelUtils.formatDatetime(self.date)
+        return dict
+
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> DeploymentLog:
+        return DeploymentLog(ModelUtils.parseDatetime(json_dict['date']), LogLevel(json_dict['level']), json_dict['message'])
+

investfly/models/TradingStrategy.py

@@ -0,0 +1,59 @@
+from abc import ABC, abstractmethod
+from typing import List, Any, Dict
+
+from investfly.models.MarketData import Security
+from investfly.models.SecurityUniverseSelector import SecurityUniverseSelector
+from investfly.models.StrategyModels import TradeSignal, StandardCloseCriteria
+from investfly.models.PortfolioModels import TradeOrder, OpenPosition, Portfolio, PositionType
+from investfly.utils.PercentBasedPortfolioAllocator import PercentBasedPortfolioAllocator
+
+
+class TradingStrategy(ABC):
+
+    def __init__(self) -> None:
+        self.state: Dict[str, int | float | bool] = {}
+
+    @abstractmethod
+    def getSecurityUniverseSelector(self) -> SecurityUniverseSelector:
+        pass
+
+    """
+    This function must be annotated with OnData to indicate when should this function be called.
+    The function is called whenever a new data is available based on the subscribed data
+    This function is called separately for each security
+    @DataParams({
+        "sma2":             {"datatype": DataType.INDICATOR, "indicator": "SMA", "barinterval": BarInterval.ONE_MINUTE,  "period": 2, "count": 2},
+        "sma3":             {"datatype": DataType.INDICATOR, "indicator": "SMA", "barinterval": BarInterval.ONE_MINUTE, "period": 3, "count": 2},
+        "allOneMinBars":    {"datatype": DataType.BARS, "barinterval": BarInterval.ONE_MINUTE},
+        "latestDailyBar":   {"datatype": DataType.BARS, "barinterval": BarInterval.ONE_DAY, "count":1},
+        "quote":            {"datatype": DataType.QUOTE},
+        "lastprice":        {"datatype": DataType.QUOTE, "field": QuoteField.LASTPRICE},
+        "allFinancials":    {"datatype": DataType.FINANCIAL},
+        "revenue":          {"datatype": DataType.FINANCIAL, "field": FinancialField.REVENUE}
+
+    })
+    """
+    @abstractmethod
+    def evaluateOpenTradeCondition(self, security: Security, data: Dict[str, Any]) -> TradeSignal | None:
+        pass
+
+    def processOpenTradeSignals(self, portfolio: Portfolio, tradeSignals: List[TradeSignal]) -> List[TradeOrder]:
+        portfolioAllocator = PercentBasedPortfolioAllocator(10, PositionType.LONG)
+        return portfolioAllocator.allocatePortfolio(portfolio, tradeSignals)
+
+    def getStandardCloseCondition(self) -> StandardCloseCriteria | None:
+        # Note that these are always executed as MARKET_ORDER
+        return None
+
+    def evaluateCloseTradeCondition(self, openPos: OpenPosition, data) -> TradeOrder | None:
+        return None
+
+    def runAtInterval(self, portfolio: Portfolio) -> List[TradeOrder]:
+        return []
+
+    # These are optional methods that strategy can implement to track states between executions
+    def getState(self) -> Dict[str, int | float | bool]:
+        return self.state
+
+    def restoreState(self, state: Dict[str, int | float | bool]) -> None:
+        self.state = state

investfly/models/__init__.py

@@ -0,0 +1,10 @@
+from investfly.models.CommonModels import DatedValue, TimeUnit, TimeDelta, Session
+from investfly.models.Indicator import ParamType, IndicatorParamSpec, IndicatorValueType, IndicatorSpec, Indicator
+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
+from investfly.models.SecurityUniverseSelector import StandardSymbolsList, CustomSecurityList, SecurityUniverseType, SecurityUniverseSelector, FinancialQuery, FinancialCondition, ComparisonOperator
+from investfly.models.StrategyModels import DataParams, ScheduleInterval, Schedule, TradeSignal, StandardCloseCriteria, PortfolioSecurityAllocator
+from investfly.models.TradingStrategy import TradingStrategy
+from investfly.models.SecurityFilterModels import DataType, DataParam, DataSource
+

investfly/samples/indicators/IndicatorTemplate.py

@@ -0,0 +1,80 @@
+# This is a self-documenting starter template to define custom indicators in Python Programming Language
+
+# Following two imports are required
+from investfly.models import *
+from investfly.utils import *
+
+# Import basic types, they aren't required but recommended
+from typing import Any, List, Dict
+
+# Following numeric analysis imports are allowed
+import math
+import statistics
+import numpy as np
+import talib
+import pandas
+
+# ! WARN ! Imports other than listed above are disallowed and won't pass validation
+
+# Create a class that extends Indicator. The class name becomes the "IndicatorId", which must be globally unique
+class SMAHeikin_CHANGE_ME(Indicator):
+
+    # At minimum, you must implement two methods (1) getIndicatorSpec and (2) shown below.
+    def getIndicatorSpec(self) -> IndicatorSpec:
+        # In this method, you must construct and return IndicatorSpec object that specifies
+        # indicator name, description and any parameters it needs.
+
+        # This information is used by Investfly UI to display information about this indicator in the expression builder
+
+        indicator = IndicatorSpec("[Change Me]: SMA Heikin Ashi")
+        indicator.description = "[ChangeMe]: SMA based on Heikin Ashi Candles"
+
+        # This indicates that the indicator value will have the same unit as stock price and can be plotted
+        # in the same y-axis as stock price as overlay. If the indicator results in a unit-less number like
+        # ADX, you will set it to IndicatorValueType.NUMBER. Other possible values are PERCENT, RATIO, BOOLEAN
+        indicator.valueType = IndicatorValueType.PRICE
+
+        # Specify indicator parameters. For each parameter, you must provide IndicatorParamSpec with
+        # paramType: one of [ParamType.INTEGER, ParamType.FLOAT, ParamType.STRING, ParamType.BOOLEAN]
+        # The remaining properties of ParamSpec are optional
+        # required: [True|False], defaults to True
+        # options:List[Any]:  List of valid values . This will make the parameter input widget appear as a dropdown
+        indicator.addParam("period", IndicatorParamSpec(paramType=ParamType.INTEGER, options=IndicatorParamSpec.PERIOD_VALUES))
+        return indicator
+
+    def computeSeries(self, params: Dict[str, Any], bars: List[Bar]) -> List[DatedValue]:
+        # In this method, you compute indicator values for provided parameter values and given data (bars in this case)
+        # For use in strategy, only the latest indicator value is required, but you must compute full series of historical
+        # values so that this indicator can be plotted in the chart and we can run also backtest strategy when this
+        # indicator is used in trading strategy
+
+        # In this template, we will calculate SMA, but using Heikin Ashi candles
+        heikinCandles = CommonUtils.toHeikinAshi(bars)
+
+        dates, close = CommonUtils.extractCloseSeries(heikinCandles)
+        sma_period = params['period']
+
+        # talib requires numpy.array instead of Python arrays, so wrap the close array into np.array
+        smaSeries = talib.SMA(np.array(close), timeperiod=sma_period)
+
+        # Converts the returned numpy.array into List[DatedValue]
+        return CommonUtils.createListOfDatedValue(dates, smaSeries)
+
+
+    # +++++++ The following methods are optional ******
+
+    def dataCountToComputeCurrentValue(self, params: Dict[str, Any]) -> int | None:
+        # As stated above, we only need the latest indicator value while evaluating strategy in real-time.
+        # Here, you return how many input data points are needed to compute just the latest indicator value.
+        # For e.g, to compute SMA(5), you need 5 data points. The return value from this method determines
+        # the length of input data that is passed to computeSeries method above when this indicator evaluates
+        # in real-time execution mode. This speeds up computation significantly by avoiding un-necessary computation
+        # The base class (Indicator) contains implementation of this method that tries to make the best guess,
+        # but it is highly recommended to override this method
+        sma_period = params['period']
+        return sma_period
+
+    def getDataSourceType(self) -> DataSource:
+        # Currenly, only bars are supported. But in the future, we will support defining indicators based on alternate data sources
+        # such as news feed etc. The default is DataSource.BARS
+        return DataSource.BARS