investfly-sdk 1.1__py3-none-any.whl → 1.3__py3-none-any.whl

investfly/__init__.py

@@ -1,3 +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,5 +1,6 @@
 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
@@ -16,9 +17,12 @@ class InvestflyApiClient:
     def __init__(self, baseUrl: str = "https://api.investfly.com"):
         self.restApiClient = RestApiClient(baseUrl)
         self.marketApi = MarketDataApiClient(self.restApiClient)
-        """Class used to make calls to /market endpoint """
+        """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) -> Session:
         """

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

investfly/api/StrategyApiClient.py

@@ -1,16 +1,21 @@
 from typing import List, Any, Dict
 from investfly.api.RestApiClient import RestApiClient
-from investfly.models.StrategyModels import TradingStrategyModel
+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 getStrategies(self) -> List[TradingStrategyModel]:
+    def listStrategies(self) -> List[TradingStrategyModel]:
         strategiesList: List[Dict[str, Any]] = self.restApiClient.doGet('/strategy/list')
-        strategiesList = list(filter(lambda jsonDict: jsonDict['type'] == 'CUSTOM', strategiesList))
+        strategiesList = list(filter(lambda jsonDict: jsonDict['type'] == 'SCRIPT', strategiesList))
         return list(map(lambda jsonDict: TradingStrategyModel.fromDict(jsonDict), strategiesList))
 
     def getStrategy(self, strategyId: int) -> TradingStrategyModel:
@@ -19,9 +24,22 @@ class StrategyApiClient:
 
     def createStrategy(self, strategyModel: TradingStrategyModel) -> TradingStrategyModel:
         strategyDict = strategyModel.toDict()
-        strategyDict['type'] = 'CUSTOM'
+        strategyDict['type'] = 'SCRIPT'
         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)
+        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

@@ -1,3 +1,17 @@
-""" This package contains REST API Client classes to make REST API calls to Investfly Backend.
+""" 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

@@ -1,11 +1,12 @@
 import argparse
 import pickle
 import os.path
-from typing import List
+import time
+from typing import List, cast
 
 from investfly.api.InvestflyApiClient import InvestflyApiClient
-from investfly.models import Session
-from investfly.models.StrategyModels import TradingStrategyModel
+from investfly.models import Session, IndicatorSpec
+from investfly.models.StrategyModels import TradingStrategyModel, BacktestResult, BacktestStatus, BacktestResultStatus
 
 from investfly import samples
 import inspect
@@ -29,10 +30,10 @@ class InvestflyCli:
     def __logoutAction(self, args: argparse.Namespace) -> None:
         self.investflyApi.logout()
 
-    def __listStrategies(self, args: argparse.Namespace) -> str:
-        strategies: List[TradingStrategyModel] = self.investflyApi.strategyApi.getStrategies()
-        strategiesDictList = list(map(lambda model: str({'strategyId': model.strategyId,  'strategyName': model.strategyName}), strategies))
-        return "\n".join(strategiesDictList)
+    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)
@@ -41,6 +42,14 @@ class InvestflyCli:
         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
@@ -50,6 +59,15 @@ class InvestflyCli:
         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)
+        code: str = cast(str, strategyModel.pythonCode)
+        with open(path, 'w') as out_file:
+            out_file.write(code)
+        return f"Strategy saved to {path}"
+
     def __updateCode(self, args: argparse.Namespace) -> str:
         strategyId = int(args.id)
         path = args.file
@@ -58,10 +76,54 @@ class InvestflyCli:
         self.investflyApi.strategyApi.updateStrategyCode(strategyId, code)
         return 'Code Updated'
 
-    def __exitAction(self, args: argparse.Namespace|None) -> None:
-        if self.investflyApi.isLoggedIn():
-            self.investflyApi.logout()
-        self.running = False
+    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 = self.investflyApi.strategyApi.getBacktestResult(strategyId)
+                backtestStatus = 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")
@@ -75,25 +137,57 @@ class InvestflyCli:
         parser_logout = subparser.add_parser('logout', help="Logout from Investfly")
         parser_logout.set_defaults(func=self.__logoutAction)
 
-        parser_listStrategies = subparser.add_parser('listStrategies', help='List Python Strategies')
-        parser_listStrategies.set_defaults(func=self.__listStrategies)
-
-        parser_copySamples = subparser.add_parser('copySamples', help='Copy Samples from SDK')
+        parser_copySamples = subparser.add_parser('copysamples', help='Copy Strategy and Indicator Samples from SDK')
         parser_copySamples.set_defaults(func=self.__copySamples)
 
-        parser_createStrategy = subparser.add_parser('createStrategy', help='Create a new trading strategy')
+        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_updateCode = subparser.add_parser('updateStrategyCode', help='Update strategy Python Code')
+        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='Python File Path relative to the project root that contains strategy code')
+        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_exit = subparser.add_parser('exit', help='Stop and Exit CLI')
-        parser_exit.set_defaults(func = self.__exitAction)
+        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:
@@ -120,75 +214,5 @@ def main():
     investflyCli = InvestflyCli()
     investflyCli.runCli()
 
-    # # Check to see if user already has a session active
-    # if os.path.exists('/tmp/loginSession'):
-    #     tmpfile = open('/tmp/loginSession', 'rb')
-    #     restApi = pickle.load(tmpfile)
-    #     tmpfile.close()
-    # else:
-    #     restApi = StrategyApiClient("https://api.investfly.com")
-    #
-    # # CLI Commands
-    # parser = argparse.ArgumentParser()
-    # subparser = parser.add_subparsers(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')
-    #
-    # subparser.add_parser('whoami', help='View your user information')
-    #
-    # subparser.add_parser('logout', help='Logout')
-    #
-    # parser_strategy = subparser.add_parser('strategy', help='View all your current strategies')
-    # parser_strategy.add_argument('-id', help='Provide the Strategy ID')
-    # parser_strategy.add_argument('-o', '--output-file', help='Provide a location to save the output file of a custom strategy (Requires Strategy ID)')
-    # parser_strategy.add_argument('-u', '--update-file', help='Provide the file location to update the script of a custom strategy (Requires Strategy ID)')
-    #
-    # args = parser.parse_args()
-    #
-    # # If user is logging in, create a new login session and save it locally
-    # if args.command == 'login':
-    #     restApi.login(args.username, args.password)
-    #     tmpFile = open('/tmp/loginSession', 'ab')
-    #     pickle.dump(restApi, tmpFile)
-    #     tmpFile.close()
-    #
-    # elif args.command == 'logout':
-    #     restApi.logout()
-    #     os.remove('/tmp/loginSession')
-    #
-    # elif args.command == 'whoami':
-    #     restApi.getStatus()
-    #
-    # elif args.command == 'strategy':
-    #     if all(e is None for e in [args.id, args.output_file, args.update_file]):
-    #         restApi.getStrategies()
-    #     elif (args.output_file is not None) and (args.id is not None):
-    #         try:
-    #             code = restApi.saveStrategy(args.id)
-    #             file = open(args.output_file, "w")
-    #             file.write(code)
-    #             file.close()
-    #             print('File successfully saved to '+args.output_file)
-    #         except Exception as e:
-    #             print(e)
-    #     elif (args.update_file is not None) and (args.id is not None):
-    #         try:
-    #             file = open(args.update_file, "r")
-    #             code = file.read()
-    #             restApi.updateStrategy(args.id, code)
-    #             file.close()
-    #         except Exception as e:
-    #             print(e)
-    #     else:
-    #         parser_strategy.print_help()
-    #
-    #
-    # else:
-    #     parser.print_help()
-
-
 if __name__ == '__main__':
-    #main()
-    print(inspect.getfile(samples))
+    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['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

investfly/models/MarketData.py

@@ -17,6 +17,10 @@ def formatDatetime(dt: datetime) -> str:
 
 
 class SecurityType(str, Enum):
+    """
+    Enum representing Security Type (STOCK, ETF)
+    """
+
     STOCK = "STOCK"
     ETF = "ETF"
 
@@ -31,8 +35,15 @@ class SecurityType(str, Enum):
 
 @dataclass(frozen=True)
 class Security:
+    """
+    Class representing a security instrument that is traded in the market
+    """
+
     symbol: str
+    """ Security Symbol """
+
     securityType: SecurityType
+    """ Security Type """
 
     @staticmethod
     def createStock(symbol: str):
@@ -48,6 +59,7 @@ class Security:
 
 @dataclass
 class Quote:
+    """ Class representing Price Quote """
     symbol: str
     date: datetime
     lastPrice: float
@@ -122,9 +134,8 @@ class Quote:
         return bar
 
 
-
-
 class BarInterval(str, Enum):
+    """ Enum to represent BarInterval """
     ONE_MINUTE = "ONE_MINUTE"
     FIVE_MINUTE = "FIVE_MINUTE"
     FIFTEEN_MINUTE = "FIFTEEN_MINUTE"

investfly/models/MarketDataIds.py

@@ -15,7 +15,7 @@ class QuoteField(str, Enum):
     DAY_CHANGE_OPEN = "DAY_CHANGE_OPEN"
 
 class FinancialField(str, Enum):
-    # fundamental metrics below
+    """Financial Fields supported by Invesfly"""
 
     # SHARE
     OUTSTANDING_SHARES = "OUTSTANDING_SHARES"
@@ -63,6 +63,7 @@ class FinancialField(str, Enum):
 
 
 class StandardIndicatorId(str, Enum):
+    """ Technical Indicator supported by Investfly"""
 
     # Works by default on DAILY bars
     AVGVOL = "AVGVOLUME"

investfly/models/PortfolioModels.py

@@ -10,6 +10,8 @@ from investfly.models.MarketData import Security
 from investfly.models.ModelUtils import ModelUtils
 
 class PositionType(str, Enum):
+    """ PositionType Enum """
+
     LONG = "LONG",
     SHORT = "SHORT"
     CLOSE = "CLOSE"
@@ -22,6 +24,8 @@ class PositionType(str, Enum):
 
 
 class TradeType(str, Enum):
+    """Trade Type Enum """
+
     BUY = "BUY"
     SELL = "SELL"
     SHORT = "SHORT"
@@ -35,6 +39,8 @@ class TradeType(str, Enum):
 
 
 class OrderType(str, Enum):
+    """Order Type Enum """
+
     MARKET_ORDER = "MARKET_ORDER"
     LIMIT_ORDER = "LIMIT_ORDER"
     STOP_ORDER = "STOP_ORDER"
@@ -43,6 +49,9 @@ class OrderType(str, Enum):
 
 
 class Broker(str, Enum):
+
+    """Broker Type Enum"""
+
     INVESTFLY = "INVESTFLY"
     TRADIER = "TRADIER"
     TDAMERITRADE = "TDAMERITRADE"
@@ -57,6 +66,7 @@ class Broker(str, Enum):
 
 @dataclass
 class TradeOrder:
+    """ A class that represents a Trade Order """
     security: Security
     tradeType: TradeType
     orderType: OrderType = OrderType.MARKET_ORDER
@@ -72,6 +82,7 @@ class TradeOrder:
 
 @dataclass
 class OrderStatus:
+    """ Trade Order Status"""
     orderId: int
     status: str
     message: str | None = None

investfly/models/SecurityUniverseSelector.py

@@ -128,10 +128,18 @@ class FinancialQuery:
 
 @dataclass
 class SecurityUniverseSelector:
+    """
+    This class is used to specify the set of stocks to use in trading strategy.
+    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.
+    """
     universeType: SecurityUniverseType
+    """The approach used to specify the stocks. Depending on the universeType, one of the attribute below must be specified"""
+
     standardList: StandardSymbolsList | None = None
-    customList: CustomSecurityList | None = None
+    "Standard Symbol List (i.e SP500, SP100). Required if `universeType` is set to `STANDARD_LIST`"
 
+    customList: CustomSecurityList | None = None
     financialQuery: FinancialQuery | None = None
 
     @staticmethod

investfly/models/StrategyModels.py

@@ -10,7 +10,7 @@ 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.PortfolioModels import PositionType, Portfolio, TradeOrder, PortfolioPerformance
 from investfly.models.SecurityFilterModels import DataParam
 
 
@@ -143,4 +143,43 @@ class TradingStrategyModel:
 
     def toDict(self) -> Dict[str, Any]:
         dict = self.__dict__.copy()
-        return dict
+        return dict
+
+
+class BacktestStatus(str, Enum):
+    NOT_STARTED = "NOT_STARTED",
+    QUEUED = "QUEUED",
+    INITIALIZING = "INITIALIZING",
+    RUNNING = "RUNNING"
+    COMPLETE = "COMPLETE"
+    ERROR = "ERROR"
+
+@dataclass
+class BacktestResultStatus:
+    jobStatus: BacktestStatus
+    percentComplete: int
+
+    def toDict(self) -> Dict[str, Any]:
+        dict = self.__dict__.copy()
+        return dict
+
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> BacktestResultStatus:
+        status = BacktestStatus[json_dict['jobStatus']]
+        percentComplete = json_dict['percentComplete']
+        return  BacktestResultStatus(status, percentComplete)
+
+@dataclass
+class BacktestResult:
+    status: BacktestResultStatus
+    performance: PortfolioPerformance
+    def toDict(self) -> Dict[str, Any]:
+        dict = self.__dict__.copy()
+        dict['performance'] = self.performance.toDict()
+        return dict
+
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> BacktestResult:
+        status = BacktestResultStatus.fromDict(json_dict['status'])
+        performance = PortfolioPerformance.fromDict(json_dict['performance'])
+        return BacktestResult(status, performance)

investfly/models/TradingStrategy.py

@@ -9,43 +9,94 @@ from investfly.utils.PercentBasedPortfolioAllocator import PercentBasedPortfolio
 
 
 class TradingStrategy(ABC):
+    """
+    This is the main interface (abstract class) used to implement a trading strategy.
+    """
 
     def __init__(self) -> None:
         self.state: Dict[str, int | float | bool] = {}
+        """The persisted state of the strategy. """
 
     @abstractmethod
     def getSecurityUniverseSelector(self) -> SecurityUniverseSelector:
+        """
+        This function is used to narrow down the set of securities (i.e stocks) against which to run your logic.
+        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.
+        See docs on
+        `investfly.models.SecurityUniverseSelector.SecurityUniverseSelector` for more details.
+        Returns
+        :return: `investfly.models.SecurityUniverseSelector.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:
+        """
+        This function must be annotated with @DataParams to indicate what data (i.e indicator values) are needed as shown below.
+        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}
+
+        })
+        ```
+        :param security: The stock security against which this is evaluated. You use it to construct TradeSignal
+        :param data: Dictionary with the requested data based on @DataParams annotation.
+
+        The keys of the data param dictionary match the keys specified in @DataParams annotation. The value depends on the datatype parameter.
+         datatype=INDICATOR, value type = `investfly.models.CommonModels.DatedValue`
+         datatype=QUOTE, field is specified, value type = `investfly.models.CommonModels.DatedValue`
+         datatype=QUOTE, field is not specified, value type is `investfly.models.MarketData.Quote` object (has dayOpen, dayHigh, dayLow, prevOpen etc)
+         datatype=BARS, value type is `investfly.models.MarketData.Bar`
+
+        Further, if the count is specified and greater than 1, value is returned as a List
+        :return:  `investfly.model.StrategyModels.TradeSignal` if open condition matches and to signal open trade, None if open trade condition does not match
+        """
         pass
 
     def processOpenTradeSignals(self, portfolio: Portfolio, tradeSignals: List[TradeSignal]) -> List[TradeOrder]:
+        """
+        This method is used to convert TradeSignals into TradeOrders. You must do this for couple reasons:
+           1. Assume 1000 stocks match the open trade condition and so you have 1000 TradeSignals, but that does not
+           mean that you want to open position for 1000 stocks in your portfolio. You may want to order those trade signals
+           by strength and limit to top 10 trade signals
+           2. Your portfolio may already have open position for a stock corresponding to particular trade signal. In that case,
+           you may wan to skip that trade signal, and prioritize opening new position for other stocks
+           3. Here, you also set TradeOrder speficiations such as order type, quantity etc
+           4. You may want to fully rebalance portfolio baseed on these new trade signals
+        :param portfolio:  Current portfolio state
+        :param tradeSignals: Trade Signals correspoding to stocks matching open trade condition
+        :return:  List of TradeOrders to execute
+        """
         portfolioAllocator = PercentBasedPortfolioAllocator(10, PositionType.LONG)
         return portfolioAllocator.allocatePortfolio(portfolio, tradeSignals)
 
     def getStandardCloseCondition(self) -> StandardCloseCriteria | None:
+        """
+        TargetProfit, StopLoss, TrailingStop and Timeout are considered as standard close criteria. This function
+        is created so that you can specify those standard close/exit conditions easily
+        :return: `investfly.models.StrategyModels.StandardCloseCriteria`
+        """
         # Note that these are always executed as MARKET_ORDER
         return None
 
     def evaluateCloseTradeCondition(self, openPos: OpenPosition, data) -> TradeOrder | None:
+        """
+        Implementing this method is optional. But when implemented, it should be implemented similar to evaluateOpenTradeCondition
+        :param openPos: The open position
+        :param data: Requested data that corresponds to the open position's security symbol
+        :return: TradeOrder if the position is supposed to be closed, None otherwise
+        """
         return None
 
     def runAtInterval(self, portfolio: Portfolio) -> List[TradeOrder]:

investfly/models/__init__.py

@@ -1,10 +1,18 @@
+""""
+This package contains all data model classes used in Strategy and Indicator definition.
+
+The main class for defining trading strategy is `investfly.models.TradingStrategy.TradingStrategy`
+
+The main class for defining custom technical indicator is `investfly.models.Indicator.Indicator`
+"""
+
 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.StrategyModels import DataParams, ScheduleInterval, Schedule, TradeSignal, StandardCloseCriteria, PortfolioSecurityAllocator, BacktestStatus
 from investfly.models.TradingStrategy import TradingStrategy
 from investfly.models.SecurityFilterModels import DataType, DataParam, DataSource
 

{investfly_sdk-1.1.dist-info → investfly_sdk-1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: investfly-sdk
-Version: 1.1
+Version: 1.3
 Summary: Investfly SDK
 Author-email: "Investfly.com" <admin@investfly.com>
 License: The MIT License (MIT)
@@ -83,25 +83,40 @@ pip install investfly-sdk
 
 **Launch investfly-cli**
 
-Investfly SDK comes with a command line tool (CLI) called investfly-cli. 
+Install investfly-sdk also adds investfly-cli in your path inside the virtual environment. It can be launched simply by using `investfly-cli` command in the virtual env.
+
 ```commandline
-investfly-cli                                                                         
+(venv) user@host$ investfly-cli 
 
 investfly-cli$ -h
-usage: investfly-cli [-h] {login,logout,listStrategies,copySamples,exit} ...
+usage: investfly-cli [-h]
+                     {login,logout,strategy.list,strategy.copysamples,strategy.create,strategy.download,strategy.update,strategy.backtest.start,strategy.backtest.stop,strategy.backtest.result,exit}
+                     ...
 
 positional arguments:
-  {login,logout,listStrategies,copySamples,exit}
+  {login,logout,strategy.list,strategy.copysamples,strategy.create,strategy.download,strategy.update,strategy.backtest.start,strategy.backtest.stop,strategy.backtest.result,exit}
                         Available Commands
     login               Login to Investfly
     logout              Logout from Investfly
-    listStrategies      List Python Strategies
-    copySamples         Copy Samples from SDK
-    ....
-    ....
+    strategy.list       List Python Strategies
+    strategy.copysamples
+                        Copy Samples from SDK
+    strategy.create     Create a new trading strategy
+    strategy.download   Download one of your strategy and save it to a file
+    strategy.update     Update strategy Python Code
+    strategy.backtest.start
+                        Start backtest for strategy
+    strategy.backtest.stop
+                        Stop backtest for strategy
+    strategy.backtest.result
+                        Get backtest result, waiting if backtest is still
+                        running
     exit                Stop and Exit CLI
 
+options:
+  -h, --help            show this help message and exit
 
+investfly-cli$ 
 ```
 
 **Test Installation**
@@ -123,7 +138,7 @@ Investfly-SDK comes with a starter strategy template and many sample strategies
 **Copy Samples**
 
 ```commandline
-investfly-cli$ copySamples
+investfly-cli$ copysamples
 Samples copied to ./samples directory
 ```
 
@@ -135,10 +150,10 @@ But for now, we'll use the unmodified sample
 investfly-cli$ login -u <YOUR_USERNAME> -p <YOUR_PASSWORD>
 Session(username='xxxxx', clientId='xxxxxx-krfs61aa', clientToken='766fad47-3e1e-4f43-a77a-72a95a395fec')
 
-investfly-cli$ createStrategy -n MySmaCrossOverStrategy -f ./samples/strategies/SmaCrossOverStrategy.py
+investfly-cli$ strategy.create -n MySmaCrossOverStrategy -f ./samples/strategies/SmaCrossOverStrategy.py
 Created strategy 83
 
-investfly-cli$ listStrategies
+investfly-cli$ strategy.list
 {'strategyId': 83, 'strategyName': 'MySmaCrossOverStrategy'}
 
 ```
@@ -148,7 +163,7 @@ investfly-cli$ listStrategies
 Edit and update ./samples/strategies/SmaCrossOverStrategy.py as you like. For testing, change the `StandardSymbolsList.SP_100` to `StandardSymbolsList.SP_500` inside `getSecurityUniverseSelector` function.  
 
 ```commandline
-investfly-cli$ updateStrategyCode --id 83 -f ./samples/strategies/SmaCrossOverStrategy.py
+investfly-cli$ strategy.update --id 83 -f ./samples/strategies/SmaCrossOverStrategy.py
 Code Updated
 ```
 
@@ -168,6 +183,10 @@ When using the IDE, open `investfly` directory created above as a project with y
 Make sure that Python Interpreter is configured to the virtual environment `investfly/venv/bin/python` created above.
 
 
+# API Docs
+
+API Docs are published at https://www.investfly.com/guides/docs/index.html
+
 # Getting Help
 Please email [admin@investfly.com](admin@investfly.com) for any support or bug report
 

investfly_sdk-1.3.dist-info/RECORD

@@ -0,0 +1,39 @@
+investfly/__init__.py,sha256=Ku0IZu4VYvNGui70Xu-bG1fB8XtVNQxBey6f5nLIKVU,71
+investfly/api/IndicatorApiClient.py,sha256=G2bEWaCvcmotp4jx-IoiqHblZZWAdwaUjDNP5ZoaagM,931
+investfly/api/InvestflyApiClient.py,sha256=I_hi1Uw8EGa3jr06cNkrGbhjIT90BPr_YN5EFilykwQ,2111
+investfly/api/MarketDataApiClient.py,sha256=bOlMzzZzN5A35oo0Iml2xCekV0jOig8Q_L66xi6n0n0,611
+investfly/api/PortfolioApiClient.py,sha256=llNISIHWSx3wvf83usGhwPhVr-3RYGAndBNpZV9w3W0,1858
+investfly/api/RestApiClient.py,sha256=XjvJCqAqUMPa7tXkhxGwaOj1xgHkfLcA8Q0027Z6xm8,3236
+investfly/api/StrategyApiClient.py,sha256=w5_hQrxtQ7-1C1uu0UKL37ZbcjXmtdBAYXPtEiM-MC4,2087
+investfly/api/__init__.py,sha256=JeeOmrsPbVk4B26DT3hbvBoxAvkMEhJ-PeKeloNGF08,600
+investfly/cli/InvestflyCli.py,sha256=SCRqC4GpaVPB7RDzMAgr7_GpEl0ai4GF1qlBKXsjUws,10565
+investfly/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investfly/models/CommonModels.py,sha256=kbyWsez1voii2K2wyflYCW7i9lYQh49nbrts4bTvvG4,2348
+investfly/models/Indicator.py,sha256=9v46Ozs2O8UPUjDzVC1MpoGx2iwnA__ZyrySVXxX8Qo,10660
+investfly/models/MarketData.py,sha256=NbyOh472uIXyHaTW9eYCBbiTu2szSq47iCz8i3qI1v0,6081
+investfly/models/MarketDataIds.py,sha256=CTNCb7G8NgLb84LYCqqxwlhO8e6RV-AUGwJH9GDv53A,3248
+investfly/models/ModelUtils.py,sha256=pnrVIDM26LqK0Wuw7gTs0c97lCLIV_fm0EUtlEfT7j4,964
+investfly/models/PortfolioModels.py,sha256=wEHzaxEMEmliNR1OXS0WNzzao7ZA5qhKIPzAjWQuUOM,8658
+investfly/models/SecurityFilterModels.py,sha256=4baTBBI-XOKh8uTpvqVvk3unD-xHoyooO3dd5lKWbXA,5806
+investfly/models/SecurityUniverseSelector.py,sha256=N2cYhgRz3PTh6T98liiiTbJNg27SBpaUaIQGgDHFbF4,8645
+investfly/models/StrategyModels.py,sha256=n9MVOJFPtc_Wkiq5TyhdQnaiTUeXGMYqLmBE9IEiW10,5553
+investfly/models/TradingStrategy.py,sha256=uUgQpZRgioVADIKerdC5VD0LEy9LvDqEEGvtRTgWASM,6381
+investfly/models/__init__.py,sha256=6uMfJwcYaH1r-T-bbh6gMud0VpnoSQTkPNDVMDE3JXo,1383
+investfly/samples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investfly/samples/indicators/IndicatorTemplate.py,sha256=X0AlStLnL1SBSnTwrtW_sthm00tmuN5V7N-GrtiarmM,4454
+investfly/samples/indicators/NewsSentiment.py,sha256=fcpAqOcNWmqYsP-xwJquCX_6G7Ntr3A1-m31eJHAUOE,65095
+investfly/samples/indicators/RsiOfSma.py,sha256=kiLvMhrsbc_lV0EEpERGW2im19u5XmyJk88aTDGSBis,1719
+investfly/samples/indicators/SmaEmaAverage.py,sha256=9pp3TtEKJADD_bfufwrWlwMswlTLoN7Nj6BC_jJ1sRs,1749
+investfly/samples/indicators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investfly/samples/strategies/SmaCrossOverStrategy.py,sha256=szjmnqQN8O7CRIS1vc-fRONKg4Dy1d59dZhiSEpEJAI,1699
+investfly/samples/strategies/SmaCrossOverTemplate.py,sha256=HSyVh89_d-k1aAzqs_WFt8EDxs809OjWq6V3VJVUNQw,8200
+investfly/samples/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+investfly/utils/CommonUtils.py,sha256=lCXAdI8-6PgbutcXJqUmSfuuLXp82FcnlxNVjCJpqLU,2631
+investfly/utils/PercentBasedPortfolioAllocator.py,sha256=oKaSjq5L_3NfRo2iayepCZtZnCevsx4XpsxFfZMTnV8,1684
+investfly/utils/__init__.py,sha256=2BqXoOQElv-GIU6wvmf2aaAABAcNny2TETcj7kf9rzM,129
+investfly_sdk-1.3.dist-info/LICENSE.txt,sha256=Jmd2U7G7Z1oNdnRERRzFXN6C--bEo_K56j4v9EpJSTg,1090
+investfly_sdk-1.3.dist-info/METADATA,sha256=Nxdk0L1ZE5eKcJzRVbofnXgfkQs6NGEUAMRFOimKZqo,7507
+investfly_sdk-1.3.dist-info/WHEEL,sha256=Z4pYXqR_rTB7OWNDYFOm1qRk0RX6GFP2o8LgvP453Hk,91
+investfly_sdk-1.3.dist-info/entry_points.txt,sha256=GDRF4baJQXTh90DvdJJx1DeRezWfPt26E567lTs3g6U,66
+investfly_sdk-1.3.dist-info/top_level.txt,sha256=dlEJ2OGWA3prqMvXELeydS5RTdpSzh7hz1LwR3NMc7A,10
+investfly_sdk-1.3.dist-info/RECORD,,

{investfly_sdk-1.1.dist-info → investfly_sdk-1.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.2.0)
+Generator: setuptools (70.3.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

investfly_sdk-1.1.dist-info/RECORD

@@ -1,38 +0,0 @@
-investfly/__init__.py,sha256=SpTl-Tg1B1HTyjNOE-8ue-N2wGnXN_2zl7RFUSxlkiM,33
-investfly/api/InvestflyApiClient.py,sha256=WBbI6i3ma09oOy6nUQO1amahV3WeorCHR0WLyaDjzw8,1735
-investfly/api/MarketDataApiClient.py,sha256=XmGIt5RK0-70cHTDF24g3YXqqxCNyzMzBIVhz1-7ZqY,460
-investfly/api/PortfolioApiClient.py,sha256=FVPjFz_eVLVXs-yPRefIcPoNiR3_WWzG7L0Dht60Z2o,1693
-investfly/api/RestApiClient.py,sha256=lnBJRlNKUZtBJ0x69oTDMHKxcZqdF2qevKjGUI0-ybo,3067
-investfly/api/StrategyApiClient.py,sha256=jsZpuSDNj5HFTAquiRmx3TgG4sO1_Un0kHdmtfJuDdg,1342
-investfly/api/__init__.py,sha256=tOUcAnM3zOUewVJ6jr-cZphc8hiFwWfR1kPVaWNJtwQ,152
-investfly/cli/InvestflyCli.py,sha256=RI3DMInpKRMgtiacAymKuxcURNJ3-4ctDrSllJNu5ic,8144
-investfly/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-investfly/models/CommonModels.py,sha256=OrwgqCiDL_HJfZTJeeVVsHUuRSDm6Ehk9xpnFy5AB5I,1663
-investfly/models/Indicator.py,sha256=FqiuiJJXCHUQtxf1AGUhIv2oYy3705D9MT3aVrJpX_s,6879
-investfly/models/MarketData.py,sha256=h7mefNLmAtLL8z75CQy0FZsSazKnsaWULt4B4Bh2uhw,5786
-investfly/models/MarketDataIds.py,sha256=8IsJmQWpi-TooQMjKDMfbZzJjzYOXGss-g10WzoMQyg,3177
-investfly/models/ModelUtils.py,sha256=pnrVIDM26LqK0Wuw7gTs0c97lCLIV_fm0EUtlEfT7j4,964
-investfly/models/PortfolioModels.py,sha256=JvqZiH0g3w9qGqEXywpgqasM9olV3n6kjH7bfy9t0Z0,8462
-investfly/models/SecurityFilterModels.py,sha256=4baTBBI-XOKh8uTpvqVvk3unD-xHoyooO3dd5lKWbXA,5806
-investfly/models/SecurityUniverseSelector.py,sha256=z4V5Ng0DQ8DVy8FeuB_7swAYO7rmSK6HfJc7vA1NCq8,8111
-investfly/models/StrategyModels.py,sha256=MjDziuLNoL25kzEYsOvqyetxGAMYNRFIYOB-I8OqJg8,4346
-investfly/models/TradingStrategy.py,sha256=dbsQ0wAY7M6s3yUpjp5cXp2X3tZwaUFB48pW-79C5D8,2825
-investfly/models/__init__.py,sha256=YVr7PakHt-g7pRmihFqYrvxNMwYE-rlDymFGp4neUdE,1071
-investfly/samples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-investfly/samples/indicators/IndicatorTemplate.py,sha256=X0AlStLnL1SBSnTwrtW_sthm00tmuN5V7N-GrtiarmM,4454
-investfly/samples/indicators/NewsSentiment.py,sha256=fcpAqOcNWmqYsP-xwJquCX_6G7Ntr3A1-m31eJHAUOE,65095
-investfly/samples/indicators/RsiOfSma.py,sha256=kiLvMhrsbc_lV0EEpERGW2im19u5XmyJk88aTDGSBis,1719
-investfly/samples/indicators/SmaEmaAverage.py,sha256=9pp3TtEKJADD_bfufwrWlwMswlTLoN7Nj6BC_jJ1sRs,1749
-investfly/samples/indicators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-investfly/samples/strategies/SmaCrossOverStrategy.py,sha256=szjmnqQN8O7CRIS1vc-fRONKg4Dy1d59dZhiSEpEJAI,1699
-investfly/samples/strategies/SmaCrossOverTemplate.py,sha256=HSyVh89_d-k1aAzqs_WFt8EDxs809OjWq6V3VJVUNQw,8200
-investfly/samples/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-investfly/utils/CommonUtils.py,sha256=lCXAdI8-6PgbutcXJqUmSfuuLXp82FcnlxNVjCJpqLU,2631
-investfly/utils/PercentBasedPortfolioAllocator.py,sha256=oKaSjq5L_3NfRo2iayepCZtZnCevsx4XpsxFfZMTnV8,1684
-investfly/utils/__init__.py,sha256=2BqXoOQElv-GIU6wvmf2aaAABAcNny2TETcj7kf9rzM,129
-investfly_sdk-1.1.dist-info/LICENSE.txt,sha256=Jmd2U7G7Z1oNdnRERRzFXN6C--bEo_K56j4v9EpJSTg,1090
-investfly_sdk-1.1.dist-info/METADATA,sha256=2kmXPPwk_sXD0ralI7pOGdkMi-KKCcl2CYTSzgFSfGk,6514
-investfly_sdk-1.1.dist-info/WHEEL,sha256=y4mX-SOX4fYIkonsAGA5N0Oy-8_gI4FXw5HNI1xqvWg,91
-investfly_sdk-1.1.dist-info/entry_points.txt,sha256=GDRF4baJQXTh90DvdJJx1DeRezWfPt26E567lTs3g6U,66
-investfly_sdk-1.1.dist-info/top_level.txt,sha256=dlEJ2OGWA3prqMvXELeydS5RTdpSzh7hz1LwR3NMc7A,10
-investfly_sdk-1.1.dist-info/RECORD,,