investfly-sdk 1.0__py3-none-any.whl → 1.2__py3-none-any.whl

investfly/__init__.py

@@ -0,0 +1,5 @@
+"""
+.. include:: ../README.md
+"""
+
+__all__ = ['api', 'models', 'utils']

investfly/api/IndicatorApiClient.py

@@ -0,0 +1,24 @@
+from typing import List, Dict, Any
+
+from investfly.api.RestApiClient import RestApiClient
+from investfly.models import IndicatorSpec
+
+
+class IndicatorApiClient:
+
+    def __init__(self, restApiClient: RestApiClient) -> None:
+        self.restApiClient = restApiClient
+
+    def listIndicators(self) -> List[IndicatorSpec]:
+        indicatorsListDict = self.restApiClient.doGet('/indicator/list/custom')
+        result: List[IndicatorSpec] = []
+        for indicatorDict in indicatorsListDict:
+            result.append(IndicatorSpec.fromDict(indicatorDict))
+        return result
+
+    def getIndicatorCode(self, indicatorId: str) -> str:
+        return self.restApiClient.doGet(f'/indicator/custom/{indicatorId}/code')
+
+    def createUpdateIndicator(self,  code: str) -> IndicatorSpec:
+        specDict: Dict[str, Any] = self.restApiClient.doPostCode('/indicator/custom/update', code)
+        return IndicatorSpec.fromDict(specDict)

investfly/api/InvestflyApiClient.py

@@ -1,23 +1,49 @@
 import datetime
 
+from investfly.api.IndicatorApiClient import IndicatorApiClient
 from investfly.api.MarketDataApiClient import MarketDataApiClient
 from investfly.api.PortfolioApiClient import PortfolioApiClient
 from investfly.api.RestApiClient import RestApiClient
+from investfly.api.StrategyApiClient import StrategyApiClient
+from investfly.models import Session
 
 
 class InvestflyApiClient:
+    """
+    Investfly API Client. This class should be used as the entry point to make all API calls.
+    After authentication, access marketApi or portfolioApi to make calls to /market or /portfolio endpoints
+    """
 
     def __init__(self, baseUrl: str = "https://api.investfly.com"):
         self.restApiClient = RestApiClient(baseUrl)
         self.marketApi = MarketDataApiClient(self.restApiClient)
+        """Class used to make calls to /marketdata and /symbol endpoint to get market and symbol data"""
         self.portfolioApi = PortfolioApiClient(self.restApiClient)
+        """Class used to make calls to /portfolio endpoint to get portfolio and brokerage account data"""
+        self.strategyApi = StrategyApiClient(self.restApiClient)
+        """Class used to make calls to /strategy endpoint to operate on trading strategies"""
+        self.indicatorApi = IndicatorApiClient(self.restApiClient)
 
-    def login(self, username, password):
+    def login(self, username, password) -> Session:
+        """
+        Login to investfly backend.
+        :param username: Username
+        :param password: Password
+        :return: Session object representing authenticated session
+        """
         return self.restApiClient.login(username, password)
 
     def logout(self):
         self.restApiClient.logout()
 
+    def isLoggedIn(self) -> bool:
+        return "investfly-client-id" in self.restApiClient.headers
+
+    def getSession(self) -> Session:
+        sessionJson = self.restApiClient.doGet('/user/session')
+        session: Session = Session.fromJsonDict(sessionJson)
+        return session
+
     @staticmethod
     def parseDatetime(date_str: str) -> datetime.datetime:
         return datetime.datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S.%f%z')

investfly/api/MarketDataApiClient.py

@@ -4,6 +4,10 @@ from investfly.api.RestApiClient import RestApiClient
 
 
 class MarketDataApiClient:
+    """
+    MarketDataApiClient is intended to make calls to /marketdata and /symbol endpoint to get market and symbol data
+    from Investfly
+    """
 
     def __init__(self, restApiClient: RestApiClient) -> None:
         self.restApiClient = restApiClient

investfly/api/PortfolioApiClient.py

@@ -6,6 +6,10 @@ from investfly.models.PortfolioModels import Broker, Portfolio, Balances, OpenPo
 
 
 class PortfolioApiClient:
+    """
+    This class is intended to make REST API calls to /portfolio endpoint to get information on virtual portfolio
+    and connected brokerage account
+    """
 
     def __init__(self, restApiClient: RestApiClient) -> None:
         self.restApiClient = restApiClient

investfly/api/RestApiClient.py

@@ -12,6 +12,11 @@ warnings.simplefilter("ignore")
 
 class RestApiClient:
 
+    """
+    Internal class to make REST API requests. Users of the SDK do not use this class directly.
+    Please use investfly.api.InvestflyApiClient` instead
+    """
+
     def __init__(self, baseUrl: str) -> None:
         self.headers: Dict[str, str] = {}
         self.baseUrl = baseUrl
@@ -30,8 +35,8 @@ class RestApiClient:
 
     def logout(self):
         requests.post(self.baseUrl + "/user/logout", verify=False)
-        self.clientId = None
-        self.clientToken = None
+        del self.headers['investfly-client-id']
+        del self.headers['investfly-client-token']
 
     def doGet(self, url: str) -> Any:
         res = requests.get(self.baseUrl + url, headers=self.headers, verify=False)

investfly/api/StrategyApiClient.py

@@ -0,0 +1,45 @@
+from typing import List, Any, Dict
+from investfly.api.RestApiClient import RestApiClient
+from investfly.models.CommonModels import Message
+from investfly.models.StrategyModels import TradingStrategyModel, BacktestResult
+
+
+class StrategyApiClient:
+
+    """
+    Class used to make calls to /strategy endpoint to operate on trading strategies.
+    """
+
+    def __init__(self, restApiClient: RestApiClient) -> None:
+        self.restApiClient = restApiClient
+
+    def listStrategies(self) -> List[TradingStrategyModel]:
+        strategiesList: List[Dict[str, Any]] = self.restApiClient.doGet('/strategy/list')
+        strategiesList = list(filter(lambda jsonDict: jsonDict['type'] == 'CUSTOM', strategiesList))
+        return list(map(lambda jsonDict: TradingStrategyModel.fromDict(jsonDict), strategiesList))
+
+    def getStrategy(self, strategyId: int) -> TradingStrategyModel:
+        strategyDict = self.restApiClient.doGet('/strategy/' + str(strategyId))
+        return TradingStrategyModel.fromDict(strategyDict)
+
+    def createStrategy(self, strategyModel: TradingStrategyModel) -> TradingStrategyModel:
+        strategyDict = strategyModel.toDict()
+        strategyDict['type'] = 'CUSTOM'
+        strategyDict = self.restApiClient.doPost('/strategy/create', strategyDict)
+        return TradingStrategyModel.fromDict(strategyDict)
+        
+    def updateStrategyCode(self, strategyId: int, code: str) -> str:
+        return self.restApiClient.doPostCode('/strategy/' + str(strategyId) + '/update/code', code)
+
+    def startBacktest(self, strategyId: int) -> Message:
+        message = self.restApiClient.doPost(f'/backtest/{strategyId}/start', {})
+        return Message.fromDict(message)
+
+    def stopBacktest(self, strategyId: int) -> Message:
+        message = self.restApiClient.doPost(f'/backtest/{strategyId}/stop', {})
+        return Message.fromDict(message)
+
+    def getBacktestResult(self, strategyId: int) -> BacktestResult:
+        resultDict: Dict[str, Any] = self.restApiClient.doGet(f'/backtest/{strategyId}/result')
+        return BacktestResult.fromDict(resultDict)
+

investfly/api/__init__.py

@@ -0,0 +1,17 @@
+""" This package contains REST API Client classes to make REST API calls to Investfly server.
+The entry point is `investfly.api.InvestflyApiClient`
+
+InvestflyApiClient has members to access specific endpoints such as strategyApi, portfolioApi etc
+
+For now, only those API methods that are commonly used during in strategy development are added in the clients.
+
+```
+from investfly.api.InvestflyApiClient import InvestflyApiClient
+api = InvestflyApiClient()
+api.login("<YOUR USERNAME>", "<YOUR PASSWORD>")
+pythonStrategies = api.strategyApi.getStrategies()
+print(pythonStrategies)
+api.logout()
+```
+
+"""

investfly/cli/InvestflyCli.py

@@ -0,0 +1,217 @@
+import argparse
+import pickle
+import os.path
+import time
+from typing import List
+
+from investfly.api.InvestflyApiClient import InvestflyApiClient
+from investfly.models import Session, IndicatorSpec
+from investfly.models.StrategyModels import TradingStrategyModel, BacktestResult, BacktestStatus, BacktestResultStatus
+
+from investfly import samples
+import inspect
+from pathlib import Path
+import shutil
+
+
+class InvestflyCli:
+
+    def __init__(self):
+        self.running: bool = True
+        self.investflyApi = InvestflyApiClient()
+
+
+    def __loginAction(self, args: argparse.Namespace) -> Session:
+        username = args.username
+        password = args.password
+        session = self.investflyApi.login(username, password)
+        return session
+
+    def __logoutAction(self, args: argparse.Namespace) -> None:
+        self.investflyApi.logout()
+
+    def __exitAction(self, args: argparse.Namespace|None) -> None:
+        if self.investflyApi.isLoggedIn():
+            self.investflyApi.logout()
+        self.running = False
+
+    def __copySamples(self, args: argparse.Namespace) -> str:
+        samplesPath = inspect.getfile(samples)
+        path = Path(samplesPath)
+        parentPath = path.parent
+        shutil.copytree(parentPath, './samples', dirs_exist_ok=True)
+        return "Samples copied to ./samples directory"
+
+
+    # ==== Strategy Command Handlers
+
+    def __listStrategies(self, args: argparse.Namespace) -> str:
+        strategies: List[TradingStrategyModel] = self.investflyApi.strategyApi.listStrategies()
+        strategiesDictList = list(map(lambda model: str({'strategyId': model.strategyId,  'strategyName': model.strategyName}), strategies))
+        return "\n".join(strategiesDictList)
+
+    def __createStrategy(self, args: argparse.Namespace) -> str:
+        name = args.name
+        path = args.file
+        with open(path, 'r') as source_file:
+            code = source_file.read()
+        tradingStrategyModel = TradingStrategyModel(strategyName=name, strategyDesc=name, pythonCode=code)
+        tradingStrategyModel = self.investflyApi.strategyApi.createStrategy(tradingStrategyModel)
+        return f'Created strategy {tradingStrategyModel.strategyId}'
+
+    def __downloadCode(self, args: argparse.Namespace) -> str:
+        strategyId = int(args.id)
+        path = args.file
+        strategyModel: TradingStrategyModel = self.investflyApi.strategyApi.getStrategy(strategyId)
+        with open(path, 'w') as out_file:
+            out_file.write(strategyModel.pythonCode)
+        return f"Strategy saved to {path}"
+
+    def __updateCode(self, args: argparse.Namespace) -> str:
+        strategyId = int(args.id)
+        path = args.file
+        with open(path, 'r') as source_file:
+            code = source_file.read()
+        self.investflyApi.strategyApi.updateStrategyCode(strategyId, code)
+        return 'Code Updated'
+
+    def __startBacktest(self, args: argparse.Namespace) -> str:
+        strategyId = int(args.id)
+        message = self.investflyApi.strategyApi.startBacktest(strategyId)
+        return str(message.toDict())
+
+    def __stopBacktest(self, args: argparse.Namespace) -> str:
+        strategyId = int(args.id)
+        message = self.investflyApi.strategyApi.stopBacktest(strategyId)
+        return str(message.toDict())
+
+    def __pollResults(self, args: argparse.Namespace) -> str:
+        strategyId = int(args.id)
+        backtestResult: BacktestResult = self.investflyApi.strategyApi.getBacktestResult(strategyId)
+        backtestStatus: BacktestResultStatus = backtestResult.status
+        print(str(backtestStatus.toDict()))
+        notFinished = backtestStatus.jobStatus == BacktestStatus.QUEUED or backtestStatus.jobStatus == BacktestStatus.INITIALIZING or backtestStatus.jobStatus == BacktestStatus.RUNNING
+        try:
+            while notFinished:
+                time.sleep(3)
+                backtestResult: BacktestResult = self.investflyApi.strategyApi.getBacktestResult(strategyId)
+                backtestStatus: BacktestResultStatus = backtestResult.status
+                print(str(backtestStatus.toDict()))
+                notFinished = backtestStatus.jobStatus == BacktestStatus.QUEUED or backtestStatus.jobStatus == BacktestStatus.INITIALIZING or backtestStatus.jobStatus == BacktestStatus.RUNNING
+        except KeyboardInterrupt as e:
+            print("Interrupted")
+            pass
+        return str(backtestResult.performance)
+
+    # ==== INDICATOR COMMAND HANDLERS
+
+    def __listIndicators(self, args: argparse.Namespace) -> str:
+        indicators: List[IndicatorSpec] = self.investflyApi.indicatorApi.listIndicators()
+        idList = list(map(lambda spec: spec.indicatorId, indicators))
+        return str(idList)
+
+    def __createUpdateIndicator(self, args: argparse.Namespace):
+        path = args.file
+        with open(path, 'r') as source_file:
+            code = source_file.read()
+        self.investflyApi.indicatorApi.createUpdateIndicator(code)
+
+    def __downloadIndicatorCode(self, args: argparse.Namespace):
+        indicatorId = args.id
+        path = args.file
+        code = self.investflyApi.indicatorApi.getIndicatorCode(indicatorId)
+        with open(path, 'w') as out_file:
+            out_file.write(code)
+        return f"Indicator saved to {path}"
+
+    def runCli(self) -> None:
+        parser = argparse.ArgumentParser(prog="investfly-cli")
+        subparser = parser.add_subparsers(help='Available Commands', dest="command")
+
+        parser_login = subparser.add_parser('login', help='Login to Investfly')
+        parser_login.add_argument('-u', '--username', required=True, help='Input username')
+        parser_login.add_argument('-p', '--password', required=True, help='Input user password')
+        parser_login.set_defaults(func=self.__loginAction)
+
+        parser_logout = subparser.add_parser('logout', help="Logout from Investfly")
+        parser_logout.set_defaults(func=self.__logoutAction)
+
+        parser_copySamples = subparser.add_parser('copysamples', help='Copy Strategy and Indicator Samples from SDK')
+        parser_copySamples.set_defaults(func=self.__copySamples)
+
+        parser_exit = subparser.add_parser('exit', help='Stop and Exit CLI')
+        parser_exit.set_defaults(func = self.__exitAction)
+
+        # ======= STRATEGY COMMANDS ==========
+
+        parser_listStrategies = subparser.add_parser('strategy.list', help='List Python Strategies')
+        parser_listStrategies.set_defaults(func=self.__listStrategies)
+
+        parser_createStrategy = subparser.add_parser('strategy.create', help='Create a new trading strategy')
+        parser_createStrategy.add_argument('-n', '--name', required=True, help='Strategy Name')
+        parser_createStrategy.add_argument('-f', '--file', required=True, help='Python File Path relative to the project root that contains strategy code')
+        parser_createStrategy.set_defaults(func=self.__createStrategy)
+
+        parser_downloadStrategy = subparser.add_parser('strategy.download', help='Download one of your strategy python code and save it to a file')
+        parser_downloadStrategy.add_argument('-i', '--id', required=True, help='Strategy ID')
+        parser_downloadStrategy.add_argument('-f', '--file', required=True, help='File path (with file name) to save strategy python code')
+        parser_downloadStrategy.set_defaults(func=self.__downloadCode)
+
+        parser_updateCode = subparser.add_parser('strategy.update', help='Update strategy Python Code')
+        parser_updateCode.add_argument('-i', '--id', required=True, help='Strategy ID')
+        parser_updateCode.add_argument('-f', '--file', required=True, help='File path (with file name) that contains strategy code')
+        parser_updateCode.set_defaults(func=self.__updateCode)
+
+        parser_startBacktest = subparser.add_parser('strategy.backtest.start', help='Start backtest for strategy')
+        parser_startBacktest.add_argument('-i', '--id', required=True, help='Strategy ID')
+        parser_startBacktest.set_defaults(func=self.__startBacktest)
+
+        parser_stopBacktest = subparser.add_parser('strategy.backtest.stop', help='Stop backtest for strategy')
+        parser_stopBacktest.add_argument('-i', '--id', required=True, help='Strategy ID')
+        parser_stopBacktest.set_defaults(func=self.__stopBacktest)
+
+        parser_resultBacktest = subparser.add_parser('strategy.backtest.result', help='Get backtest result, waiting if backtest is still running')
+        parser_resultBacktest.add_argument('-i', '--id', required=True, help='Strategy ID')
+        parser_resultBacktest.set_defaults(func=self.__pollResults)
+
+        # ====== INDICATOR COMMANDS ====
+
+        parser_listIndicators = subparser.add_parser('indicator.list', help='List Custom Indicators')
+        parser_listIndicators.set_defaults(func=self.__listIndicators)
+
+        parser_downloadIndicator = subparser.add_parser('indicator.download', help='Download indicator python code and save it to a file')
+        parser_downloadIndicator.add_argument('-i', '--id', required=True, help='IndicatorId ID')
+        parser_downloadIndicator.add_argument('-f', '--file', required=True,  help='File path (with file name) to save indicator python code')
+        parser_downloadIndicator.set_defaults(func=self.__downloadIndicatorCode)
+
+        parser_createUpdateIndicator = subparser.add_parser('indicator.update', help='Create or update indicator. Indicator ID is retried from ClassName')
+        parser_createUpdateIndicator.add_argument('-f', '--file', required=True, help='File path (with file name) that contains indicator code')
+        parser_createUpdateIndicator.set_defaults(func=self.__createUpdateIndicator)
+
+        while self.running:
+            try:
+                data = input("\ninvestfly-cli$ ")
+                args = parser.parse_args(data.split())
+                if args.command is None:
+                    # When user hits Enter without any command
+                    parser.print_help()
+                else:
+                    result = args.func(args)
+                    if result is not None:
+                        print(result)
+            except SystemExit:
+                # System exit is caught because when -h is used, argparser displays help and exists the apputils with SystemExit
+                pass
+            except KeyboardInterrupt:
+                self.__exitAction(None)
+            except Exception as e:
+                print("Received exception " + str(e))
+
+
+
+def main():
+    investflyCli = InvestflyCli()
+    investflyCli.runCli()
+
+if __name__ == '__main__':
+    main()

investfly/models/CommonModels.py

@@ -10,6 +10,9 @@ from investfly.models.ModelUtils import ModelUtils
 
 @dataclass
 class DatedValue:
+    """
+    Data Container class to hold Time,Value for timed numeric values
+    """
     date: datetime
     value: float | int
 
@@ -25,6 +28,11 @@ class DatedValue:
 
 
 class TimeUnit(str, Enum):
+
+    """
+    TimeUnit Enum (MINUTES, HOURS, DAYS)
+    """
+
     MINUTES = "MINUTES"
     HOURS = "HOURS"
     DAYS = "DAYS"
@@ -38,6 +46,7 @@ class TimeUnit(str, Enum):
 
 @dataclass
 class TimeDelta:
+    """ TimeDelta container class similar to python timedelta """
     value: int
     unit: TimeUnit
 
@@ -58,9 +67,31 @@ class TimeDelta:
         return TimeDelta(json_dict['value'], TimeUnit[json_dict['unit']])
 
 
+class MessageType(str, Enum):
+    ERROR = "ERROR"
+    SUCCESS = "SUCCESS"
+    WARN = "WARN"
+
+@dataclass
+class Message:
+    type: MessageType
+    message: str
+
+    def toDict(self) -> Dict[str, Any]:
+        return self.__dict__.copy()
+
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> Message:
+        return Message(MessageType[json_dict['type']], json_dict['message'])
+
+
+
 
 @dataclass
 class Session:
+
+    """ Class that represents logged in user session with the Investfly server """
+
     username: str
     clientId: str
     clientToken: str

investfly/models/Indicator.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from enum import Enum
@@ -9,6 +11,9 @@ from investfly.models.SecurityFilterModels import DataSource, DataParam
 
 
 class ParamType(str, Enum):
+
+    """ Indicator Param Type """
+
     INTEGER = 'INTEGER'
     FLOAT = 'FLOAT'
     BOOLEAN = 'BOOLEAN'
@@ -24,12 +29,22 @@ class ParamType(str, Enum):
 
 @dataclass
 class IndicatorParamSpec:
+
+    """ Class that represents Indicator Parameter Specification """
+
     paramType: ParamType
+    """ Parameter Type (INTEGER, FLOAT, BOOLEAN, STRING, BARINTERVAL) """
 
     required: bool = True
+    """ Whether this parameter is required or optional"""
+
     # The default value here is just a "hint" to the UI to auto-fill indicator value with reasonable default
     defaultValue: Any | None = None
+    """ The default value for the parameter to auto-populate mainly in UI """
+
     options: List[Any] | None = None
+    """ 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]
 
@@ -37,10 +52,20 @@ class IndicatorParamSpec:
         d = self.__dict__.copy()
         return d
 
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> IndicatorParamSpec:
+        paramType = ParamType[json_dict['paramType']]
+        required = json_dict['required']
+        defaultValue = json_dict.get('defaultValue')
+        options = json_dict.get('options')
+        return IndicatorParamSpec(paramType, required, defaultValue, options)
+
 
 class IndicatorValueType(str, Enum):
-    # Indicator ValueType can possibly used by Investfly to validate expression and optimize experience for users
-    # For e.g, all Indicators of same valueType can be plotted in the same y-axis
+    """
+    Indicator ValueType can possibly used by Investfly to validate expression and optimize experience for users
+    For e.g, all Indicators of same valueType can be plotted in the same y-axis
+    """
 
     PRICE = "PRICE"
 
@@ -92,28 +117,85 @@ class IndicatorSpec:
         jsonDict['params'] = paramsDict
         return jsonDict
 
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> IndicatorSpec:
+        name = json_dict['name']
+        indicatorSpec: IndicatorSpec = IndicatorSpec(name)
+        indicatorSpec.indicatorId = json_dict['indicatorId']
+        indicatorSpec.description = json_dict.get('description')
+        indicatorSpec.valueType = IndicatorValueType[json_dict['valueType']]
+        for key, value in json_dict['params'].items():
+            indicatorSpec.params[key] = IndicatorParamSpec.fromDict(value)
+        return indicatorSpec
+
     def __str__(self):
         return str(self.__dict__)
 
 
 class Indicator(ABC):
+    """
+    The primary class to implement a custom Indicator. A Custom Indicator is like standard indicator (e.g SMA, RSI)
+    and can be used in any place that standard indicator can be used (e.g screener, charts, strategy etc)
+    Investfly comes with a set of standard indicators. If you find that the indicator you want is not supported
+    or you can a small variation (e.g SMA but with using Heikin Ashi Candles), then you can use this function
+    """
 
     @abstractmethod
     def getIndicatorSpec(self) -> IndicatorSpec:
-        # Return IndicatorDefinition with name, description, required params, and valuetype
-        # See IndicatorDefinition abstract class for more details
+        """
+        Return IndicatorSpec with name, description, required params, and valuetype
+        See IndicatorSpec abstract class for more details
+        :return:  `IndicatorSpec`
+        """
+
         pass
 
     def getDataSourceType(self) -> DataSource:
-        # Return the DataSource that this indicator is based on. Possible values are:
-        # DataSource.BARS, DataSource.QUOTE, DataSource.NEWS, DataSource.FINANCIAL
+        """
+        Return the DataSource that this indicator is based on. Possible values are:
+        DataSource.BARS, DataSource.QUOTE, DataSource.NEWS, DataSource.FINANCIAL
+        :return: `investfly.models.SecurityFilterModels.DataSource`
+        """
+
         return DataSource.BARS
 
     @abstractmethod
     def computeSeries(self, params: Dict[str, Any], data: List[Any]) -> List[DatedValue]:
-        # Indicator series is needed for backtest and plotting on stock chart
+        """
+        Compute indicator series based on provided input timed data series and parameter values.
+        This function must return List of indicator values instead of only the most recent single value because indicator
+        series is required to plot in the price chart and also to use in backtest
+        The timestamps in the `investfly.models.CommonModels.DatedValue` must correspond to timestamps in input data
+        The length of input data depends on context (e.g is this indicator being evaluated for backtest or screener?)
+        and  `dataCountToComputeCurrentValue` function below
+
+        :param params: User supplied indicator parameter values. The keys match the keys from `IndicatorSpec.params`
+        :param data: List of timed data values as specified in `Indicator.getDataSourceType`.
+        :return: List of `investfly.models.CommonModels.DatedValue` representing indicator values for each timeunit
+        """
+
         pass
 
+    def dataCountToComputeCurrentValue(self, params: Dict[str, Any]) -> int | None:
+        """
+        When this indicator is used in screener and trading strategy when is evaluated in real-time, only
+        the "current" value of the indicator is required. The historical values are NOT required. Therefore,
+        when the system calls `computeSeries` above with all available data (e.g 10 years of historical bars),
+        then it is un-necessarily slow and wasteful. This function is used to control the size of input data
+        that will be passed to `computeSeries` method above.
+
+        The default implementation tries to make the best guess, but override as needed
+
+        :param params: User supplied input parameter  values
+        :return: integer representing how many input data points are required to compute the 'current' indicator value.
+        For e.g, if this was SMA indicator with period=5, then you should return 5
+        """
+        total = 0
+        for key, value in params.items():
+            if isinstance(value, int) and key != DataParam.COUNT:
+                total += value
+        return max(total, 1)
+
     def validateParams(self, paramVals:  Dict[str, Any]):
         spec: IndicatorSpec = self.getIndicatorSpec()
         for paramName, paramSpec in spec.params.items():
@@ -139,13 +221,6 @@ class Indicator(ABC):
                         raise Exception(f"Param {paramName} provided value {paramVal} is not one of the allowed value")
 
 
-    def dataCountToComputeCurrentValue(self, params: Dict[str, Any]) -> int | None:
-        total = 0
-        for key, value in params.items():
-            if isinstance(value, int) and key != DataParam.COUNT:
-                total += value
-        return max(total, 1)
-
     def addStandardParamsToDef(self, indicatorDef: IndicatorSpec):
         # Note that setting default values for optional params impact alias/key generation for indicator instances (e.g SMA_5_1MIN_1)
         # Hence, its better to leave them as None