plotting for other instruments

Author: Graeme22

README.md

@@ -31,10 +31,7 @@ tt pf (portfolio)      view and close positions, check margin and analyze BP usa
 tt trade               buy or sell stocks/ETFs, crypto, and futures
 tt order               view, replace, and cancel orders
 tt plot                plot charts directly in the terminal! requires `gnuplot` installed
-```
-Unavailable commands pending development:
-```
-tt wl (watchlist)      view current prices and other data for symbols in your watchlists
+tt wl (watchlist)      view prices and metrics for symbols in your watchlists (pending further development!)
 ```
 For more options, run `tt --help` or `tt <subcommand> --help`.
 

pyproject.toml

@@ -39,7 +39,7 @@ authors = [
 dependencies = [
     "py-gnuplot>=1.3",
     "rich>=13.8.1",
-    "tastytrade>=10.1.1",
+    "tastytrade>=10.2.0",
     "typer>=0.15.3",
 ]
 dynamic = ["version"]

ttcli/__init__.py

@@ -4,5 +4,5 @@
 
 CUSTOM_CONFIG_PATH = ".config/ttcli/ttcli.cfg"
 TOKEN_PATH = ".config/ttcli/.session"
-VERSION = "0.5.0"
+VERSION = "0.6.0"
 __version__ = VERSION

ttcli/app.py

@@ -12,6 +12,7 @@
 from ttcli.portfolio import portfolio
 from ttcli.trade import trade
 from ttcli.utils import config_path
+from ttcli.watchlist import watchlist
 
 cli = Typer()
 
@@ -39,6 +40,7 @@ def main(
 cli.add_typer(plot, name="plot")
 cli.add_typer(portfolio, name="pf")
 cli.add_typer(trade, name="trade")
+cli.add_typer(watchlist, name=None)
 
 
 if __name__ == "__main__":

ttcli/plot.py

@@ -7,10 +7,11 @@
 from pygnuplot.gnuplot import Gnuplot
 from tastytrade import DXLinkStreamer
 from tastytrade.dxfeed import Candle
+from tastytrade.instruments import Cryptocurrency, Future, FutureProduct
 from tastytrade.utils import NYSE, TZ, now_in_new_york
 from typer import Option
 
-from ttcli.utils import AsyncTyper, RenewableSession
+from ttcli.utils import AsyncTyper, RenewableSession, print_error
 
 plot = AsyncTyper(help="Plot candle charts, portfolio P&L, or net liquidating value.")
 fmt = "%Y-%m-%d %H:%M:%S"
@@ -28,13 +29,7 @@ class CandleType(str, Enum):
     YEAR = "1y"
 
 
-@plot.command(help="Plot candle chart for the given symbol.")
-async def stock(
-    symbol: str,
-    width: Annotated[
-        CandleType, Option("--width", "-w", help="Interval of time for each candle.")
-    ] = CandleType.HALF_HOUR,
-):
+def get_start_time(width: CandleType) -> datetime:
     now = now_in_new_york()
     today = now.date()
     end = today if now.time() > time(9, 30) else today - timedelta(days=1)
@@ -50,23 +45,10 @@ async def stock(
     else:
         valid_days = NYSE.valid_days(today - timedelta(days=5), end).to_pydatetime()  # type: ignore
         start_day = valid_days[-1].date()
-    start_time = datetime.combine(start_day, time(9, 30), TZ)
-    sesh = RenewableSession()
-    candles: list[str] = []
-    ts = round(start_time.timestamp() * 1000)
-    async with DXLinkStreamer(sesh) as streamer:
-        await streamer.subscribe_candle([symbol], width.value, start_time)
-        async for candle in streamer.listen(Candle):
-            if candle.close:
-                date_str = datetime.strftime(
-                    datetime.fromtimestamp(candle.time / 1000, TZ), fmt
-                )
-                candles.append(
-                    f"{date_str},{candle.open},{candle.high},{candle.low},{candle.close}",
-                )
-            if candle.time == ts:
-                break
-    candles.sort()
+    return datetime.combine(start_day, time(9, 30), TZ)
+
+
+def gnuplot(sesh: RenewableSession, symbol: str, candles: list[str]) -> None:
     gnu = Gnuplot()
     tmp = tempfile.NamedTemporaryFile(delete=False)
     with open(tmp.name, "w") as f:
@@ -100,3 +82,107 @@ async def stock(
     )
     _ = input()
     os.system("clear")
+
+
+@plot.command(help="Plot candle chart for the given symbol.")
+async def stock(
+    symbol: str,
+    width: Annotated[
+        CandleType, Option("--width", "-w", help="Interval of time for each candle.")
+    ] = CandleType.HALF_HOUR,
+):
+    sesh = RenewableSession()
+    candles: list[str] = []
+    start_time = get_start_time(width)
+    ts = round(start_time.timestamp() * 1000)
+    async with DXLinkStreamer(sesh) as streamer:
+        await streamer.subscribe_candle([symbol], width.value, start_time)
+        async for candle in streamer.listen(Candle):
+            if candle.close:
+                date_str = datetime.strftime(
+                    datetime.fromtimestamp(candle.time / 1000, TZ), fmt
+                )
+                candles.append(
+                    f"{date_str},{candle.open},{candle.high},{candle.low},{candle.close}",
+                )
+            if candle.time == ts:
+                break
+    candles.sort()
+    gnuplot(sesh, symbol, candles)
+
+
+@plot.command(help="Plot candle chart for the given symbol.")
+async def crypto(
+    symbol: str,
+    width: Annotated[
+        CandleType, Option("--width", "-w", help="Interval of time for each candle.")
+    ] = CandleType.HALF_HOUR,
+):
+    sesh = RenewableSession()
+    symbol = symbol.upper()
+    if "USD" not in symbol:
+        symbol += "/USD"
+    elif "/" not in symbol:
+        symbol = symbol.split("USD")[0] + "/USD"
+    crypto = Cryptocurrency.get(sesh, symbol)
+    candles: list[str] = []
+    start_time = get_start_time(width)
+    ts = round(start_time.timestamp() * 1000)
+    if not crypto.streamer_symbol:
+        raise Exception("Missing streamer symbol for instrument!")
+    async with DXLinkStreamer(sesh) as streamer:
+        await streamer.subscribe_candle(
+            [crypto.streamer_symbol], width.value, start_time
+        )
+        async for candle in streamer.listen(Candle):
+            if candle.close:
+                date_str = datetime.strftime(
+                    datetime.fromtimestamp(candle.time / 1000, TZ), fmt
+                )
+                candles.append(
+                    f"{date_str},{candle.open},{candle.high},{candle.low},{candle.close}",
+                )
+            if candle.time == ts:
+                break
+    candles.sort()
+    gnuplot(sesh, crypto.symbol, candles)
+
+
+@plot.command(help="Plot candle chart for the given symbol.")
+async def future(
+    symbol: str,
+    width: Annotated[
+        CandleType, Option("--width", "-w", help="Interval of time for each candle.")
+    ] = CandleType.HALF_HOUR,
+):
+    sesh = RenewableSession()
+    symbol = symbol.upper()
+    if symbol[0] != "/":
+        symbol = "/" + symbol
+    if not any(c.isdigit() for c in symbol):
+        product = FutureProduct.get(sesh, symbol)
+        _fmt = ",".join([f" {m.name} ({m.value})" for m in product.active_months])
+        print_error(
+            f"Please enter the full futures symbol!\nCurrent active months:{_fmt}"
+        )
+        return
+    future = Future.get(sesh, symbol)
+    candles: list[str] = []
+    start_time = get_start_time(width)
+    ts = round(start_time.timestamp() * 1000)
+    async with DXLinkStreamer(sesh) as streamer:
+        await streamer.subscribe_candle(
+            [future.streamer_symbol], width.value, start_time
+        )
+        async for candle in streamer.listen(Candle):
+            if candle.close:
+                date_str = datetime.strftime(
+                    datetime.fromtimestamp(candle.time / 1000, TZ), fmt
+                )
+                candles.append(
+                    f"{date_str},{candle.open},{candle.high},{candle.low},{candle.close}",
+                )
+            if candle.time == ts:
+                break
+    candles.sort()
+    gnuplot(sesh, future.symbol, candles)

ttcli/portfolio.py

@@ -1,4 +1,3 @@
-import asyncio
 from collections import defaultdict
 from datetime import date, datetime
 from decimal import Decimal
@@ -8,7 +7,7 @@
 from rich.table import Table
 from tastytrade import DXLinkStreamer
 from tastytrade.account import MarginReportEntry
-from tastytrade.dxfeed import Greeks, Summary, Trade
+from tastytrade.dxfeed import Greeks
 from tastytrade.instruments import (
     Cryptocurrency,
     Equity,
@@ -17,7 +16,7 @@
     Option as TastytradeOption,
     TickSize,
 )
-from tastytrade.market_data import get_market_data
+from tastytrade.market_data import a_get_market_data_by_type, get_market_data
 from tastytrade.metrics import MarketMetricInfo, get_market_metrics
 from tastytrade.order import (
     InstrumentType,
@@ -108,9 +107,11 @@ async def positions(
     greeks_symbols = [o.streamer_symbol for o in options] + [
         fo.streamer_symbol for fo in future_options
     ]
-    equity_symbols = [
-        p.symbol for p in positions if p.instrument_type == InstrumentType.EQUITY
-    ] + [o.underlying_symbol for o in options]
+    equity_symbols = (
+        [p.symbol for p in positions if p.instrument_type == InstrumentType.EQUITY]
+        + [o.underlying_symbol for o in options]
+        + ["SPY"]
+    )
     equities = Equity.get(sesh, equity_symbols)
     equity_dict = {e.symbol: e for e in equities}
     all_symbols = (
@@ -125,20 +126,22 @@ async def positions(
         + greeks_symbols
     )
     all_symbols = [s for s in all_symbols if s]
-    async with DXLinkStreamer(sesh) as streamer:
-        greeks_task = asyncio.create_task(
-            listen_events(greeks_symbols, Greeks, streamer)
-        )
-        summary_task = asyncio.create_task(
-            listen_events(all_symbols, Summary, streamer)
-        )
-        await asyncio.gather(greeks_task, summary_task)
-        await streamer.subscribe(Trade, ["SPY"])
-        spy = await streamer.get_event(Trade)
-        greeks_dict = greeks_task.result()
-        summary_dict = {
-            k: v.prev_day_close_price or ZERO for k, v in summary_task.result().items()
-        }
+    if greeks_symbols:
+        async with DXLinkStreamer(sesh) as streamer:
+            greeks_dict = await listen_events(greeks_symbols, Greeks, streamer)
+    else:
+        greeks_dict = {}
+    data = await a_get_market_data_by_type(
+        sesh,
+        cryptocurrencies=crypto_symbols or None,
+        equities=equity_symbols,
+        futures=futures_symbols or None,
+        options=options_symbols or None,
+        future_options=future_options_symbols or None,
+    )
+    data_dict = {d.symbol: d for d in data}
+    prev_close = lambda s: data_dict[s].prev_close or ZERO
+    spy = data_dict["SPY"].last or ZERO
     tt_symbols = set(pos.symbol for pos in positions)
     tt_symbols.update(set(o.underlying_symbol for o in options))
     tt_symbols.update(set(o.underlying_symbol for o in future_options))
@@ -204,12 +207,12 @@ async def positions(
             metrics = metrics_dict[o.underlying_symbol]
             ticks = equity_dict[o.underlying_symbol].option_tick_sizes or []
             beta = metrics.beta or 0
-            bwd = beta * mark * delta / spy.price
+            bwd = beta * mark * delta / spy
             ivr = (metrics.tos_implied_volatility_index_rank or 0) * 100
             indicators = get_indicators(today, metrics)
             trade_price = pos.average_open_price
             pnl = (mark_price - trade_price) * m * pos.multiplier
-            day_change = mark_price - summary_dict[o.streamer_symbol]
+            day_change = mark_price - prev_close(o.symbol)
             pnl_day = day_change * pos.quantity * pos.multiplier
         elif pos.instrument_type == InstrumentType.FUTURE_OPTION:
             o = future_options_dict[pos.symbol]
@@ -223,14 +226,14 @@ async def positions(
             metrics = metrics_dict[o.root_symbol]
             indicators = get_indicators(today, metrics)
             bwd = (
-                (summary_dict[f.streamer_symbol] * metrics.beta * delta / spy.price)
+                (prev_close(f.symbol) * metrics.beta * delta / spy)
                 if metrics.beta
                 else 0
             )
             ivr = (metrics.tos_implied_volatility_index_rank or 0) * 100
             trade_price = pos.average_open_price
             pnl = (mark_price - trade_price) * m * pos.multiplier
-            day_change = mark_price - summary_dict[o.streamer_symbol]
+            day_change = mark_price - prev_close(o.symbol)
             pnl_day = day_change * pos.quantity * pos.multiplier
         elif pos.instrument_type == InstrumentType.EQUITY:
             theta = 0
@@ -243,11 +246,11 @@ async def positions(
             closing[i + 1] = e
             beta = metrics.beta or 0
             indicators = get_indicators(today, metrics)
-            bwd = beta * mark_price * delta / spy.price
+            bwd = beta * mark_price * delta / spy
             ivr = (metrics.tos_implied_volatility_index_rank or 0) * 100
             pnl = mark - pos.average_open_price * pos.quantity * m
             trade_price = pos.average_open_price
-            day_change = mark_price - summary_dict[pos.symbol]
+            day_change = mark_price - prev_close(pos.symbol)
             pnl_day = day_change * pos.quantity
         elif pos.instrument_type == InstrumentType.FUTURE:
             theta = 0
@@ -259,11 +262,11 @@ async def positions(
             # BWD = beta * stock price * delta / index price
             metrics = metrics_dict[f.future_product.root_symbol]  # type: ignore
             indicators = get_indicators(today, metrics)
-            bwd = (metrics.beta * mark_price * delta / spy.price) if metrics.beta else 0
+            bwd = (metrics.beta * mark_price * delta / spy) if metrics.beta else 0
             ivr = (metrics.tw_implied_volatility_index_rank or 0) * 100
             trade_price = pos.average_open_price
             pnl = (mark_price - trade_price) * pos.quantity * m * f.notional_multiplier
-            day_change = mark_price - summary_dict[f.streamer_symbol]
+            day_change = mark_price - prev_close(f.symbol)
             pnl_day = day_change * pos.quantity * f.notional_multiplier
             net_liq = pnl_day
         elif pos.instrument_type == InstrumentType.CRYPTOCURRENCY:
@@ -279,7 +282,7 @@ async def positions(
             c = crypto_dict[pos.symbol]
             ticks = [TickSize(value=c.tick_size)]
             closing[i + 1] = c
-            day_change = mark_price - summary_dict[c.streamer_symbol]  # type: ignore
+            day_change = mark_price - prev_close(c.symbol)
             pnl_day = day_change * pos.quantity * pos.multiplier
         else:
             print_warning(
@@ -342,7 +345,7 @@ async def positions(
         delta_diff = delta_target - sums["bwd"]
         if abs(delta_diff) > delta_variation:
             print_warning(
-                f"Portfolio beta-weighting misses target of {delta_target} substantially!"
+                f"Portfolio beta weight misses target of {delta_target} substantially!"
             )
     close = get_confirmation("Close out a position? y/N ", default=False)
     if not close:

ttcli/utils.py

@@ -18,7 +18,7 @@
 from tastytrade.streamer import U
 from typer import Typer
 
-from ttcli import CUSTOM_CONFIG_PATH, TOKEN_PATH, logger
+from ttcli import CUSTOM_CONFIG_PATH, TOKEN_PATH, VERSION, logger
 
 ZERO = Decimal(0)
 
@@ -103,7 +103,7 @@ def command(self, *args: Any, **kwargs: Any) -> Any:
 
 class RenewableSession(Session):
     def __init__(self):
-        token_path = os.path.join(os.path.expanduser("~"), TOKEN_PATH)
+        token_path = os.path.join(os.path.expanduser("~"), f"{TOKEN_PATH}.v{VERSION}")
         logged_in = False
         # try to load token
         if os.path.exists(token_path):

ttcli/watchlist.py

@@ -0,0 +1,13 @@
+from typer import Typer
+
+from ttcli.utils import print_warning
+
+
+watchlist = Typer()
+
+
+@watchlist.command(
+    name="wl", help="Show prices and metrics for symbols in the given watchlist."
+)
+def filter(name: str):
+    print_warning("This functionality hasn't been implemented yet!")