investfly-sdk 1.0__py3-none-any.whl

investfly/models/MarketData.py

@@ -0,0 +1,177 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import TypedDict, Dict, Any, cast
+
+from investfly.models.CommonModels import DatedValue
+from investfly.models.MarketDataIds import QuoteField
+
+def parseDatetime(date_str: str) -> datetime:
+    return datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S.%f%z')
+
+
+def formatDatetime(dt: datetime) -> str:
+    return dt.strftime('%Y-%m-%dT%H:%M:%S.%f%z')
+
+
+class SecurityType(str, Enum):
+    STOCK = "STOCK"
+    ETF = "ETF"
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+
+# All enums subclass str to make them JSON serializable
+
+@dataclass(frozen=True)
+class Security:
+    symbol: str
+    securityType: SecurityType
+
+    @staticmethod
+    def createStock(symbol: str):
+        return Security(symbol, SecurityType.STOCK)
+
+    @staticmethod
+    def fromDict(jsonDict: Dict[str, Any]) -> Security:
+        return Security(jsonDict["symbol"], SecurityType[jsonDict["securityType"]])
+
+    def toDict(self) -> Dict[str, Any]:
+        return self.__dict__.copy()
+
+
+@dataclass
+class Quote:
+    symbol: str
+    date: datetime
+    lastPrice: float
+    prevClose: float| None = None
+    todayChange: float | None = None
+    todayChangePercent: float | None = None
+    dayOpen: float | None = None
+    dayHigh: float | None = None
+    dayLow: float | None = None
+    dayVolume: int | None = None
+
+    @staticmethod
+    def fromDict(jsonDict: Dict[str, Any]) -> Quote:
+        quote = Quote(jsonDict["symbol"], parseDatetime(jsonDict["date"]), jsonDict["lastPrice"])
+        quote.prevClose = jsonDict.get('prevClose')
+        quote.todayChange = jsonDict.get("todayChange")
+        quote.todayChangePercent = jsonDict.get('todayChangePercent')
+        quote.dayOpen = jsonDict.get('dayOpen')
+        quote.dayHigh = jsonDict.get('dayHigh')
+        quote.dayLow = jsonDict.get('dayLow')
+        return quote
+
+    def toDict(self) -> Dict[str, Any]:
+        jsonDict = self.__dict__.copy()
+        jsonDict["date"] = formatDatetime(self.date)
+        return jsonDict
+
+    def toIndicatorValue(self, quoteField: QuoteField) -> DatedValue:
+        if quoteField == QuoteField.LASTPRICE:
+            return DatedValue(self.date, self.lastPrice)
+        elif quoteField == QuoteField.DAY_OPEN:
+            if self.dayOpen is None:
+                raise Exception("DAY_OPEN price not available in Quote")
+            return DatedValue(self.date, self.dayOpen)
+        elif quoteField == QuoteField.DAY_HIGH:
+            if self.dayHigh is None:
+                raise Exception("DAY_HIGH price not available in Quote")
+            return DatedValue(self.date, self.dayHigh)
+        elif quoteField == QuoteField.DAY_LOW:
+            if self.dayLow is None:
+                raise Exception("DAY_LOW price not available in Quote")
+            return DatedValue(self.date, self.dayLow)
+        elif quoteField == QuoteField.PREV_DAY_CLOSE:
+            if self.prevClose is None:
+                raise Exception("PREV_DAY_CLOSE price not available in Quote")
+            return DatedValue(self.date, self.prevClose)
+        elif quoteField == QuoteField.DAY_CHANGE:
+            if self.todayChange is None:
+                raise Exception("DAY_CHANGE not available in Quote")
+            return DatedValue(self.date, self.todayChange)
+        elif quoteField == QuoteField.DAY_CHANGE_PCT:
+            if self.todayChangePercent is None:
+                raise Exception("DAY_CHANGE_PCT value not available in Quote")
+            return DatedValue(self.date, self.todayChangePercent)
+        elif quoteField == QuoteField.DAY_VOLUME:
+            if self.dayVolume is None:
+                raise Exception("DAY_VOLUME not available in Quote")
+            return DatedValue(self.date, self.dayVolume)
+        else:
+            raise Exception("Invalid Quote Indicator ID: " + quoteField)
+
+    def toEODBar(self) -> Bar:
+        bar = Bar()
+        bar['symbol'] = self.symbol
+        bar['barinterval'] = BarInterval.ONE_DAY
+        bar['date'] = self.date.replace(second=0, microsecond=0)
+        bar['open'] = cast(float, self.dayOpen)
+        bar['high'] = cast(float, self.dayHigh)
+        bar['low'] = cast(float, self.dayLow)
+        bar['close'] = cast(float, self.lastPrice)
+        bar['volume'] = cast(int, self.dayVolume)
+        return bar
+
+
+
+
+class BarInterval(str, Enum):
+    ONE_MINUTE = "ONE_MINUTE"
+    FIVE_MINUTE = "FIVE_MINUTE"
+    FIFTEEN_MINUTE = "FIFTEEN_MINUTE"
+    THIRTY_MINUTE = "THIRTY_MINUTE"
+    SIXTY_MINUTE = "SIXTY_MINUTE"
+    ONE_DAY = "ONE_DAY"
+
+    def getMinutes(self) -> int:
+        if self == BarInterval.ONE_MINUTE:
+            return 1
+        elif self == BarInterval.FIVE_MINUTE:
+            return 5
+        elif self == BarInterval.FIFTEEN_MINUTE:
+            return 15
+        elif self == BarInterval.THIRTY_MINUTE:
+            return 30
+        elif self == BarInterval.SIXTY_MINUTE:
+            return 60
+        else:
+            return 24 * 60
+
+
+
+Bar = TypedDict("Bar", {"symbol": str,
+                        "barinterval": BarInterval,
+                        "date": datetime,
+                        "open": float,
+                        "close": float,
+                        "high": float,
+                        "low": float,
+                        "volume": int
+                        },
+                total=False)
+
+@dataclass
+class StockNews:
+    date: datetime
+    title: str
+    description: str
+
+
+class NoDataException(Exception):
+    def __init__(self,  dataParams: Dict[str, Any]):
+        self.message = f"Data Not Available: {dataParams}"
+
+    def __str__(self) -> str:
+        return self.message
+
+    def __repr__(self) -> str:
+        return self.message

investfly/models/MarketDataIds.py

@@ -0,0 +1,119 @@
+from enum import Enum
+
+
+class QuoteField(str, Enum):
+    # ------ Quote ---
+    LASTPRICE = "LASTPRICE"
+    DAY_OPEN = "DAY_OPEN"
+    DAY_HIGH = "DAY_HIGH"
+    DAY_LOW = "DAY_LOW"
+    DAY_VOLUME = "DAY_VOLUME"
+    PREV_DAY_CLOSE = "PREV_DAY_CLOSE"
+    DAY_CHANGE = "DAY_CHANGE"
+    DAY_CHANGE_PCT = "DAY_CHANGE_PCT"
+    DAY_CHANGE_OPEN = "DAY_CHANGE_OPEN"
+
+class FinancialField(str, Enum):
+    # fundamental metrics below
+
+    # SHARE
+    OUTSTANDING_SHARES = "OUTSTANDING_SHARES"
+    MARKET_CAP = "MARKET_CAP"
+
+    # INCOME STATEMENT
+    REVENUE = "REVENUE"
+    COST_OF_REVENUE = "COST_OF_REVENUE"
+    GROSS_PROFIT = "GROSS_PROFIT"
+    OPERATING_EXPENSE = "OPERATING_EXPENSE"
+    OPERATING_INCOME = "OPERATING_INCOME"
+    NET_INCOME = "NET_INCOME"  # subtract taxes to get net income
+    EPS = "EPS"
+
+    # BALANCE SHEET: Assets = Liabilities + Equity
+    CURR_ASSETS = "CURR_ASSETS"
+    NON_CURR_ASSETS = "NON_CURR_ASSETS"
+    ASSETS = "ASSETS"
+    CURR_LIABILITIES = "CURR_LIABILITIES"
+    NON_CURR_LIABILITIES = "NON_CURR_LIABILITIES"
+    LIABILITIES = "LIABILITIES"
+    LONG_TERM_DEBT = "LONG_TERM_DEBT"
+    EQUITY = "EQUITY"
+
+    # CASH FLOW
+    OPEARTING_CASH_FLOW = "OPEARTING_CASH_FLOW"
+    INVESTING_CASH_FLOW = "INVESTING_CASH_FLOW"
+    FINANCING_CASH_FLOW = "FINANCING_CASH_FLOW"
+    NET_CASH_FLOW = "NET_CASH_FLOW"
+
+    RETURN_ON_EQUITY = "RETURN_ON_EQUITY"
+    RETURN_ON_ASSETS = "RETURN_ON_ASSETS"
+    PRICE_TO_EARNINGS_RATIO = "PRICE_TO_EARNINGS_RATIO"
+    PEG_RATIO = "PEG_RATIO"
+    PRICE_TO_SALES_RATIO = "PRICE_TO_SALES_RATIO"
+    PRICE_TO_BOOK_RATIO = "PRICE_TO_BOOK_RATIO"
+    REVENUE_GROWTH = "REVENUE_GROWTH"
+    EPS_GROWTH = "EPS_GROWTH"
+    DEBT_EQUITY_RATIO = "DEBT_EQUITY_RATIO"
+    CURRENT_RATIO = "CURRENT_RATIO"
+    GROSS_MARGIN = "GROSS_MARGIN"
+    PROFIT_MARGIN = "PROFIT_MARGIN"
+
+    DIVIDEND_YIELD = "DIVIDEND_YIELD"
+
+
+class StandardIndicatorId(str, Enum):
+
+    # Works by default on DAILY bars
+    AVGVOL = "AVGVOLUME"
+    HIGH_52_WEEK = "HIGH52WEEK"
+    LOW_52_WEEK = "LOW52WEEK"
+
+    DRAWDOWN = "DRAWDOWN"
+    PERCENTCHANGE = "PRICECHANGEPCT"
+
+    SMA = "SMA"
+    EMA = "EMA"
+    MACD = "MACD"
+    MACDS = "MACDS"
+    RSI = "RSI"
+    ATR = "ATR"
+    ADX = "ADX"
+    PLUS_DI = "PLUS_DI"
+    MINUS_DI = "MINUS_DI"
+    PSAR = "PSAR"
+    STD_DEV = "STD_DEV"
+
+    BBAND = "BBAND"  # composite, only for chart
+    UPPER_BBAND = "UPPER_BBAND"
+    LOWER_BBAND = "LOWER_BBAND"
+    WILLIAM_R = "WILLIAM_R"
+    ROC = "ROC"
+    CCI = "CCI"
+
+    CMO = "CMO"
+    CMO_SMOOTHED = "CMO_SMOOTHED"
+    MEDIAN_PRICE = "MEDIAN_PRICE"
+    TYPICAL_PRICE = "TYPICAL_PRICE"
+    ULTIMATE_OSC = "ULTIMATE_OSC"
+    PPO = "PPO"
+
+    STOCHASTICS = "STOCHASTICS"  # composite only for charts
+    FAST_STOCHASTIC_OSC = "FAST_STOCHASTIC_OSC"
+    SLOW_STOCHASTIC_OSC = "SLOW_STOCHASTIC_OSC"
+
+    MAX = "MAX"
+    MIN = "MIN"
+
+    DOJI = "DOJI"
+    HAMMER = "HAMMER"
+
+    INVERTED_HAMMER = "INVERTED_HAMMER"
+    DRAGONFLY_DOJI = "DRAGONFLY_DOJI"
+    GRAVESTONE_DOJI = "GRAVESTONE_DOJI"
+    HANGING_MAN = "HANGING_MAN"
+
+    BULLISH = "BULLISH"
+    BEARISH = "BEARISH"
+
+    SUPPORT = "SUPPORT"
+    RESISTANCE = "RESISTANCE"

investfly/models/ModelUtils.py

@@ -0,0 +1,34 @@
+from datetime import datetime
+import pytz
+
+
+class ModelUtils:
+
+    # In Java, using Date includes timezone offset in JSON whereas using LocalDateTime does not
+
+    est_tz = pytz.timezone('America/New_York')
+
+    @staticmethod
+    def localizeDateTime(dt: datetime) -> datetime:
+        return ModelUtils.est_tz.localize(dt)
+
+
+    @staticmethod
+    def parseDatetime(date_str: str) -> datetime:
+        dt = datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S.%f')
+        dt = dt.astimezone(ModelUtils.est_tz)
+        return dt
+
+    @staticmethod
+    def formatDatetime(dt: datetime) -> str:
+        return dt.strftime('%Y-%m-%dT%H:%M:%S.%f')
+
+    @staticmethod
+    def parseZonedDatetime(date_str: str) -> datetime:
+        dt = datetime.strptime(date_str, '%Y-%m-%dT%H:%M:%S.%f%z')
+        dt = dt.astimezone(ModelUtils.est_tz)
+        return dt
+
+    @staticmethod
+    def formatZonedDatetime(dt: datetime) -> str:
+        return dt.strftime('%Y-%m-%dT%H:%M:%S.%f%z')

investfly/models/PortfolioModels.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import List, Dict, Any, cast
+
+from investfly.models.CommonModels import DatedValue
+from investfly.models.MarketData import Security
+from investfly.models.ModelUtils import ModelUtils
+
+class PositionType(str, Enum):
+    LONG = "LONG",
+    SHORT = "SHORT"
+    CLOSE = "CLOSE"
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+
+class TradeType(str, Enum):
+    BUY = "BUY"
+    SELL = "SELL"
+    SHORT = "SHORT"
+    COVER = "COVER"
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+
+class OrderType(str, Enum):
+    MARKET_ORDER = "MARKET_ORDER"
+    LIMIT_ORDER = "LIMIT_ORDER"
+    STOP_ORDER = "STOP_ORDER"
+    ONE_CANCEL_OTHER = "ONE_CANCEL_OTHER"
+    CUSTOM_CONDITION = "CUSTOM_CONDITION"
+
+
+class Broker(str, Enum):
+    INVESTFLY = "INVESTFLY"
+    TRADIER = "TRADIER"
+    TDAMERITRADE = "TDAMERITRADE"
+    BACKTEST = "BACKTEST"
+
+    def __str__(self):
+        return self.value
+
+    def __repr__(self):
+        return self.value
+
+
+@dataclass
+class TradeOrder:
+    security: Security
+    tradeType: TradeType
+    orderType: OrderType = OrderType.MARKET_ORDER
+    quantity: int | None = None
+    maxAmount: float | None = None
+    limitPrice: float | None = None # If left empty, will use latest quote as limit price
+
+    def toDict(self) -> Dict[str, Any]:
+        jsonDict = self.__dict__.copy()
+        jsonDict["security"] = self.security.toDict()
+        return jsonDict
+
+
+@dataclass
+class OrderStatus:
+    orderId: int
+    status: str
+    message: str | None = None
+
+    @staticmethod
+    def fromDict(jsonDict: Dict[str, Any]) -> OrderStatus:
+        status = OrderStatus(jsonDict["orderId"], jsonDict["status"])
+        status.message = jsonDict.get("message")
+        return status
+
+
+@dataclass
+class PendingOrder(TradeOrder):
+    orderId: str | None = None
+    status: str | None = None
+    scheduledDate: datetime | None = None
+
+    @staticmethod
+    def fromDict(jsonDict: Dict[str, Any]) -> Any:
+        security = Security.fromDict(jsonDict["security"])
+        pendingOrder = PendingOrder(security, TradeType(jsonDict["tradeType"]))
+        pendingOrder.quantity = jsonDict.get("quantity")
+        pendingOrder.maxAmount = jsonDict.get("maxAmount")
+        pendingOrder.orderId = jsonDict.get("orderId")
+        pendingOrder.status = jsonDict.get("status")
+        pendingOrder.scheduledDate = ModelUtils.parseZonedDatetime(cast(str, jsonDict.get("scheduledDate")))
+        return pendingOrder
+
+
+@dataclass()
+class Balances:
+    buyingPower: float
+    cashBalance: float
+    currentValue: float
+    initialAmount: float | None = None
+
+    @staticmethod
+    def fromDict(jsonDict: Dict[str, Any]) -> Balances:
+        balances = Balances(jsonDict["buyingPower"],
+                            jsonDict["cashBalance"],
+                            jsonDict["currentValue"])
+        balances.initialAmount = jsonDict.get("initialAmount")
+        return balances
+
+
+@dataclass
+class CompletedTrade:
+    security: Security
+    date: datetime
+    price: float
+    quantity: int
+    tradeType: TradeType
+
+    @staticmethod
+    def fromDict(jsonDict: Dict[str, Any]) -> CompletedTrade:
+        security = Security.fromDict(jsonDict["security"])
+        date = ModelUtils.parseZonedDatetime(jsonDict["date"])
+        return CompletedTrade(security, date, jsonDict["price"], jsonDict["quantity"], TradeType[jsonDict["tradeType"]])
+
+
+@dataclass
+class ClosedPosition:
+    security: Security
+    position: PositionType
+    openDate: datetime
+    closeDate: datetime
+    openPrice: float
+    closePrice: float
+    quantity: int
+    profitLoss: float|None = None
+    percentChange: float| None = None
+
+    @staticmethod
+    def fromDict(jsonDict: Dict[str, Any]) -> ClosedPosition:
+        security = Security.fromDict(jsonDict['security'])
+        position = PositionType[jsonDict['position']]
+        openDate = ModelUtils.parseZonedDatetime(jsonDict['openDate'])
+        closeDate = ModelUtils.parseZonedDatetime((jsonDict['closeDate']))
+        openPrice = jsonDict['openPrice']
+        closePrice = jsonDict['closePrice']
+        quantity = jsonDict['quantity']
+
+        closedPosition =  ClosedPosition(security, position, openDate, closeDate, openPrice, closePrice, quantity)
+        if "profitLoss" in jsonDict:
+            closedPosition.profitLoss = jsonDict['profitLoss']
+        if "percentChange" in jsonDict:
+            closedPosition.percentChange = jsonDict['percentChange']
+
+        return closedPosition
+
+    def toDict(self) -> Dict[str, Any]:
+        jsonDict = self.__dict__.copy()
+        jsonDict["security"] = self.security.toDict()
+        jsonDict["position"] = self.position.value
+        jsonDict["openDate"] = ModelUtils.formatZonedDatetime(self.openDate)
+        jsonDict["closeDate"] = ModelUtils.formatZonedDatetime((self.closeDate))
+        return jsonDict
+
+@dataclass
+class OpenPosition:
+    security: Security
+    position: PositionType
+    avgPrice: float
+    quantity: int
+    purchaseDate: datetime
+    currentPrice: float | None = None
+    currentValue: float | None = None
+    profitLoss: float | None = None
+    percentChange: float | None = None
+
+    @staticmethod
+    def fromDict(jsonDict: Dict[str, Any]) -> OpenPosition:
+        security = Security.fromDict(jsonDict["security"])
+        openPos = OpenPosition(security,
+                               PositionType(jsonDict["position"]),
+                               jsonDict["avgPrice"],
+                               jsonDict["quantity"],
+                               ModelUtils.parseZonedDatetime(jsonDict["purchaseDate"])
+                               )
+        openPos.currentPrice = jsonDict.get("currentPrice")
+        openPos.currentValue = jsonDict.get("currentValue")
+        openPos.profitLoss = jsonDict.get("profitLoss")
+        openPos.percentChange = jsonDict.get("percentChange")
+        return openPos
+
+    def toDict(self) -> Dict[str, Any]:
+        jsonDict = self.__dict__.copy()
+        jsonDict["security"] = self.security.toDict()
+        jsonDict["purchaseDate"] = ModelUtils.formatZonedDatetime(self.purchaseDate)
+        return jsonDict
+
+
+class Portfolio:
+    def __init__(self, portfolioId: str, broker: Broker, balances: Balances) -> None:
+        self.portfolioId = portfolioId
+        self.broker = broker
+        self.balances: Balances = balances
+        self.openPositions: List[OpenPosition] = []
+        self.pendingOrders: List[PendingOrder] = []
+        self.completedTrades: List[CompletedTrade] = []
+
+    def __str__(self) -> str:
+        json_dict = self.__dict__.copy()
+        json_dict["openPositions"] = len(self.openPositions)
+        json_dict["completedTrades"] = len(self.completedTrades)
+        json_dict["pendingOrders"] = len(self.pendingOrders)
+        return str(json_dict)
+
+    def __repr__(self):
+        return self.__str__()
+
+
+@dataclass
+class PortfolioPerformance:
+    netReturn: float|None = None
+    annualizedReturn: float|None = None
+    profitFactor: float|None = None
+
+    totalTrades: int | None = None
+    winRatioPct: float| None = None
+    avgProfitPerTradePct: float| None = None
+    avgLossPerTradePct: float| None = None
+
+    meanReturnPerTradePct: float | None = None
+    sharpeRatioPerTrade: float | None = None
+
+    maxDrawdownPct: float|None = None
+    portfolioValues: List[DatedValue]|None = None
+
+    def toDict(self) -> Dict[str, Any]:
+        jsonDict = self.__dict__.copy()
+        if self.portfolioValues is not None:
+            jsonDict["portfolioValues"] = [dv.toJsonDict() for dv in self.portfolioValues]
+        else:
+            jsonDict['portfolioValues'] = []
+        return jsonDict
+
+    @staticmethod
+    def fromDict(jsonDict: Dict[str, Any]) -> PortfolioPerformance:
+        perf = PortfolioPerformance()
+        for key, value in jsonDict.items():
+            setattr(perf, key, value)
+        if 'portfolioValues' in jsonDict:
+            perf.portfolioValues = [ DatedValue.fromDict(dv) for dv in jsonDict['portfolioValues']]
+        else:
+            perf.portfolioValues = []
+        return perf
+
+    def __str__(self):
+        jsonDict = self.__dict__.copy()
+        if 'portfolioValues' in jsonDict:
+            del jsonDict['portfolioValues']
+        return str(jsonDict)
+
+    def __repr__(self):
+        return self.__str__()