investfly-sdk 1.0__tar.gz

investfly_sdk-1.0/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023+ Investfly, Finverse LLC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

investfly_sdk-1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.1
+Name: investfly-sdk
+Version: 1.0
+Summary: Investfly SDK
+Author-email: "Investfly.com" <admin@investfly.com>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2023+ Investfly, Finverse LLC
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+Project-URL: Homepage, https://www.investfly.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: certifi==2023.7.22
+Requires-Dist: charset-normalizer==3.2.0
+Requires-Dist: idna==3.4
+Requires-Dist: pandas==2.0.3
+Requires-Dist: pandas-stubs==2.0.3.230814
+Requires-Dist: pandas-ta==0.3.14b0
+Requires-Dist: python-dateutil==2.8.2
+Requires-Dist: pytz==2023.3
+Requires-Dist: requests==2.31.0
+Requires-Dist: types-requests==2.31.0.2
+Requires-Dist: six==1.16.0
+Requires-Dist: tzdata==2023.3
+Requires-Dist: urllib3==1.26.15
+Requires-Dist: numpy==1.26.4
+
+# About
+
+Python-SDK to work with Investfly API.
+[Investfly](https://www.investfly.com)
+

investfly_sdk-1.0/README.md

@@ -0,0 +1,5 @@
+# About
+
+Python-SDK to work with Investfly API.
+[Investfly](https://www.investfly.com)
+

investfly_sdk-1.0/investfly/api/InvestflyApiClient.py

@@ -0,0 +1,23 @@
+import datetime
+
+from investfly.api.MarketDataApiClient import MarketDataApiClient
+from investfly.api.PortfolioApiClient import PortfolioApiClient
+from investfly.api.RestApiClient import RestApiClient
+
+
+class InvestflyApiClient:
+
+    def __init__(self, baseUrl: str = "https://api.investfly.com"):
+        self.restApiClient = RestApiClient(baseUrl)
+        self.marketApi = MarketDataApiClient(self.restApiClient)
+        self.portfolioApi = PortfolioApiClient(self.restApiClient)
+
+    def login(self, username, password):
+        return self.restApiClient.login(username, password)
+
+    def logout(self):
+        self.restApiClient.logout()
+
+    @staticmethod
+    def parseDatetime(date_str: str) -> datetime.datetime:
+        return datetime.datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S.%f%z')

investfly_sdk-1.0/investfly/api/MarketDataApiClient.py

@@ -0,0 +1,16 @@
+from typing import Set, List, Dict, Any
+
+from investfly.api.RestApiClient import RestApiClient
+
+
+class MarketDataApiClient:
+
+    def __init__(self, restApiClient: RestApiClient) -> None:
+        self.restApiClient = restApiClient
+
+    def getNews(self, symbol: str) -> List[Dict[str, Any]]:
+        return self.restApiClient.doGet(f"/symbol/news?symbols={symbol}")
+
+
+    def getStandardSymbols(self, standardListName: str) -> Set[str]:
+        return {"AAPL"}

investfly_sdk-1.0/investfly/api/PortfolioApiClient.py

@@ -0,0 +1,37 @@
+from typing import Any, Dict
+
+from investfly.api.RestApiClient import RestApiClient
+from investfly.models.PortfolioModels import Broker, Portfolio, Balances, OpenPosition, CompletedTrade, PendingOrder, \
+    TradeOrder, OrderStatus
+
+
+class PortfolioApiClient:
+
+    def __init__(self, restApiClient: RestApiClient) -> None:
+        self.restApiClient = restApiClient
+
+    def getPortfolio(self, portfolioId: str, broker: Broker) -> Portfolio:
+        portfolioDict: Dict[str, Any] = self.restApiClient.doGet(f"/portfolio/{broker.value}/{portfolioId}")
+        balances = Balances.fromDict(portfolioDict)
+        portfolio = Portfolio(portfolioDict["portfolioId"], Broker(portfolioDict["broker"]), balances)
+
+        openPosList = self.restApiClient.doGet(f'/portfolio/{broker.value}/{portfolioId}/portfoliostocks')
+        for openPosDict in openPosList:
+            portfolio.openPositions.append(OpenPosition.fromDict(openPosDict))
+
+        completedTradesList = self.restApiClient.doGet(f'/portfolio/{broker.value}/{portfolioId}/trades')
+        for compTradeDict in completedTradesList:
+            portfolio.completedTrades.append(CompletedTrade.fromDict(compTradeDict))
+
+        pendingOrdersList = self.restApiClient.doGet(f'/portfolio/{broker.value}/{portfolioId}/pending')
+        for pendingOrderDict in pendingOrdersList:
+            portfolio.pendingOrders.append(PendingOrder.fromDict(pendingOrderDict))
+
+        return portfolio
+
+    def submitTradeOrder(self, portfolioId: str, broker: Broker, order: TradeOrder) -> OrderStatus:
+        res = self.restApiClient.doPost(f'/portfolio/{broker.value}/{portfolioId}/trade', order.toDict())
+        return OrderStatus.fromDict(res)
+
+
+

investfly_sdk-1.0/investfly/api/RestApiClient.py

@@ -0,0 +1,81 @@
+import logging
+import warnings
+from typing import Dict, Any
+
+import requests
+from requests import Response
+
+from investfly.models.CommonModels import Session
+
+warnings.simplefilter("ignore")
+
+
+class RestApiClient:
+
+    def __init__(self, baseUrl: str) -> None:
+        self.headers: Dict[str, str] = {}
+        self.baseUrl = baseUrl
+        self.log = logging.getLogger(self.__class__.__name__)
+
+    def login(self, username: str, password: str) -> Session:
+        res = requests.post(self.baseUrl + "/user/login", auth=(username, password), verify=False)
+        if res.status_code == 200:
+            self.headers['investfly-client-id'] = res.headers['investfly-client-id']
+            self.headers['investfly-client-token'] = res.headers['investfly-client-token']
+            dict_obj = res.json()
+            session = Session.fromJsonDict(dict_obj)
+            return session
+        else:
+            raise RestApiClient.getException(res)
+
+    def logout(self):
+        requests.post(self.baseUrl + "/user/logout", verify=False)
+        self.clientId = None
+        self.clientToken = None
+
+    def doGet(self, url: str) -> Any:
+        res = requests.get(self.baseUrl + url, headers=self.headers, verify=False)
+        # This does not actually return JSON string, but instead returns Python Dictionary/List etc
+        if res.status_code == 200:
+            contentType: str = res.headers['Content-Type']
+            if "json" in contentType:
+                return res.json()
+            else:
+                return res.text
+        else:
+            raise RestApiClient.getException(res)
+
+    def doPost(self, url: str, obj: Dict[str, Any]) -> Any:
+        res: Response = requests.post(self.baseUrl + url, json=obj, headers=self.headers, verify=False)
+        if res.status_code == 200:
+            contentType: str = res.headers['Content-Type']
+            if "json" in contentType:
+                return res.json()
+            else:
+                return res.text
+        else:
+            raise RestApiClient.getException(res)
+        
+    def doPostCode(self, url: str, code: str) -> Any:
+        res: Response = requests.post(self.baseUrl + url, data=code, headers=self.headers, verify=False)
+        if res.status_code == 200:
+            contentType: str = res.headers['Content-Type']
+            if "json" in contentType:
+                return res.json()
+            else:
+                return res.text
+        else:
+            raise RestApiClient.getException(res)
+
+    @staticmethod
+    def getException(res: Response):
+        try:
+            # Server returns valid JSON in case of any exceptions that may occor while processing request
+            errorObj: Dict[str, Any] = res.json()
+            if 'message' in errorObj.keys():
+                return Exception(errorObj.get('message'))
+            else:
+                return Exception(str(errorObj))
+        except requests.exceptions.JSONDecodeError:
+            # Just in case, there are other errors
+            return Exception(res.text)

investfly_sdk-1.0/investfly/cli/CliApiClient.py

@@ -0,0 +1,46 @@
+import requests
+from investfly.api.RestApiClient import RestApiClient
+
+class CliApiClient:
+
+    def __init__(self, baseUrl: str) -> None:
+        self.restApi = RestApiClient(baseUrl)
+
+    def login(self, username: str, password: str):
+        try: 
+            user = self.restApi.login(username, password)
+            print("Successfully logged in as: "+user.username)
+        except Exception as e:
+            print(e)
+    
+    def logout(self):
+        self.restApi.logout()
+
+    def getStatus(self):
+        try:
+            userInfo = self.restApi.doGet('/user/session')
+            print("Currently logged in as "+userInfo['username'])
+        except Exception as e:
+            print(e)
+
+    def getStrategies(self):
+        try:
+            strategies = self.restApi.doGet('/strategy/list')
+            for strategy in strategies:
+                print(str(strategy['strategyId'])+'\t'+strategy['strategyName']+'\n'+strategy['strategyDesc']+'\n')
+        except Exception as e:
+            print(e)
+
+    def saveStrategy(self, strategyId: int):
+        try:
+            strategy = self.restApi.doGet('/strategy/'+str(strategyId))
+            return strategy['pythonCode']
+        except Exception as e:
+            return e
+        
+    def updateStrategy(self, id: int, code: str):
+        try:
+            self.restApi.doPostCode('/strategy/'+id+'/update/code', code)
+            print('Strategy successfully updated')
+        except Exception as e:
+            print(e)

investfly_sdk-1.0/investfly/cli/commands.py

@@ -0,0 +1,78 @@
+import argparse
+import pickle
+import os.path
+
+from investfly.cli.CliApiClient import CliApiClient
+
+def main():
+    # 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 = CliApiClient("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()

investfly_sdk-1.0/investfly/models/CommonModels.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import timedelta, datetime
+from enum import Enum
+from typing import Any, Dict
+
+from investfly.models.ModelUtils import ModelUtils
+
+
+@dataclass
+class DatedValue:
+    date: datetime
+    value: float | int
+
+    def toJsonDict(self) -> Dict[str, Any]:
+        return {
+            'date': ModelUtils.formatDatetime(self.date),
+            'value': self.value
+        }
+
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> DatedValue:
+        return DatedValue(ModelUtils.parseDatetime(json_dict['date']), json_dict['value'])
+
+
+class TimeUnit(str, Enum):
+    MINUTES = "MINUTES"
+    HOURS = "HOURS"
+    DAYS = "DAYS"
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+
+@dataclass
+class TimeDelta:
+    value: int
+    unit: TimeUnit
+
+    def toPyTimeDelta(self) -> timedelta:
+        totalMinutes = self.value
+        if self.unit == TimeUnit.HOURS:
+            totalMinutes = totalMinutes * 60
+        elif self.unit == TimeUnit.DAYS:
+            totalMinutes = totalMinutes * 60 * 24
+
+        return timedelta(minutes=totalMinutes)
+
+    def toDict(self) -> Dict[str, Any]:
+        return self.__dict__.copy()
+
+    @staticmethod
+    def fromDict(json_dict: Dict[str, Any]) -> TimeDelta:
+        return TimeDelta(json_dict['value'], TimeUnit[json_dict['unit']])
+
+
+
+@dataclass
+class Session:
+    username: str
+    clientId: str
+    clientToken: str
+
+    @staticmethod
+    def fromJsonDict(json_dict: Dict[str, Any]) -> Session:
+        return Session(json_dict['username'], json_dict['clientId'], json_dict['clientToken'])

investfly_sdk-1.0/investfly/models/Indicator.py

@@ -0,0 +1,164 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum
+from typing import Any, Dict, List,  ClassVar
+
+from investfly.models.CommonModels import DatedValue
+from investfly.models.MarketData import BarInterval
+from investfly.models.SecurityFilterModels import DataSource, DataParam
+
+
+class ParamType(str, Enum):
+    INTEGER = 'INTEGER'
+    FLOAT = 'FLOAT'
+    BOOLEAN = 'BOOLEAN'
+    STRING = 'STRING'
+    BARINTERVAL = 'BARINTERVAL'
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+
+@dataclass
+class IndicatorParamSpec:
+    paramType: ParamType
+
+    required: bool = True
+    # The default value here is just a "hint" to the UI to auto-fill indicator value with reasonable default
+    defaultValue: Any | None = None
+    options: List[Any] | None = None
+
+    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]
+
+    def toDict(self) -> Dict[str, Any]:
+        d = self.__dict__.copy()
+        return d
+
+
+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
+
+    PRICE = "PRICE"
+
+    # Values that ranges from 0-100
+    PERCENT = "PERCENT"
+
+    # Values that ranges from 0-1
+    RATIO = "RATIO"
+
+    # The value must be 0 or 1
+    BOOLEAN = "BOOLEAN"
+
+    # For arbitrary numeric value, use NUMBER, which is also the default
+    NUMBER = "NUMBER"
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+# IndicatorDefinition represents indicator used in Investfly. Each indicator implementation must provide
+# IndicatorDefinition, that specifies its name, description, required parameters and what type of value
+# it returns.
+
+class IndicatorSpec:
+
+    def __init__(self, name: str) -> None:
+        # indicatorId is automatically set to clazz name of the indicator implementation
+        self.indicatorId: str
+
+        self.name: str = name
+
+        # Description is defaulted to name for simplicity but can be set properly after instantiation
+        self.description: str = name
+
+        self.valueType: IndicatorValueType = IndicatorValueType.NUMBER
+        self.params: Dict[str, IndicatorParamSpec] = {}
+
+    def addParam(self, paramName: str, paramSpec: IndicatorParamSpec) -> None:
+        self.params[paramName] = paramSpec
+
+    def toJsonDict(self) -> Dict[str, Any]:
+        jsonDict = self.__dict__.copy()
+        # IndicatorParamSpec.toDict() must be called
+        paramsDict = {}
+        for paramName in self.params.keys():
+            paramsDict[paramName] = self.params[paramName].toDict()
+        jsonDict['params'] = paramsDict
+        return jsonDict
+
+    def __str__(self):
+        return str(self.__dict__)
+
+
+class Indicator(ABC):
+
+    @abstractmethod
+    def getIndicatorSpec(self) -> IndicatorSpec:
+        # Return IndicatorDefinition with name, description, required params, and valuetype
+        # See IndicatorDefinition abstract class for more details
+        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 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
+        pass
+
+    def validateParams(self, paramVals:  Dict[str, Any]):
+        spec: IndicatorSpec = self.getIndicatorSpec()
+        for paramName, paramSpec in spec.params.items():
+            paramVal: Any = paramVals.get(paramName)
+            expectedParamType = paramSpec.paramType
+
+            if paramVal is not None:
+                if expectedParamType == ParamType.INTEGER and not isinstance(paramVal, int):
+                    raise Exception(f"Param {paramName} must be of type int. You provided: {paramVal}")
+                if expectedParamType == ParamType.FLOAT and not isinstance(paramVal, float) and isinstance(paramVal,int):
+                    raise Exception(f"Param {paramName} must be of type float. You provided: {paramVal}")
+                if expectedParamType == ParamType.STRING and not isinstance(paramVal, str):
+                    raise Exception(f"Param {paramName} must be of type string. You provided: {paramVal}")
+                if expectedParamType == ParamType.BOOLEAN and not isinstance(paramVal, bool):
+                    raise Exception(f"Param {paramName} must be of type boolean. You provided: {paramVal}")
+                if expectedParamType == ParamType.BOOLEAN and not isinstance(paramVal, bool):
+                    raise Exception(f"Param {paramName} must be of type boolean. You provided: {paramVal}")
+                if expectedParamType == ParamType.BARINTERVAL and not isinstance(paramVal, BarInterval):
+                    raise Exception(f"Param {paramName} must be of type BarInterval. You provided: {paramVal}")
+
+                if paramSpec.options is not None:
+                    if paramVal not in paramSpec.options:
+                        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
+        indicatorDef.params[DataParam.COUNT] = IndicatorParamSpec(ParamType.INTEGER, False, None)
+        indicatorDef.params[DataParam.LOOKBACK] = IndicatorParamSpec(ParamType.INTEGER, False, None, [1,2,3,4,5,6,7,8,9,10])
+        indicatorDef.params[DataParam.SECURITY] = IndicatorParamSpec(ParamType.STRING, False)
+
+        # Add datasource dependent parameters
+        dataSource = self.getDataSourceType()
+        if dataSource == DataSource.BARS:
+            indicatorDef.params[DataParam.BARINTERVAL] = IndicatorParamSpec(ParamType.BARINTERVAL, True, BarInterval.ONE_MINUTE,   [v for v in BarInterval])
+        elif dataSource == DataSource.FINANCIAL or dataSource == DataSource.QUOTE:
+            # Its optional because in the absense of field, indicator.computeSeries() will be passed full FinancialDict
+            indicatorDef.params[DataParam.FIELD] = IndicatorParamSpec(ParamType.STRING, False)
+
+