overload to simplify classmethods (#230)

* overload to simplify classmethods

* update docs, split watchlist into public/private

* fix tests

* update workflow

Author: Graeme22

.github/workflows/python-app.yml

@@ -31,4 +31,6 @@ jobs:
       env:
         TT_USERNAME: ${{ secrets.TT_USERNAME }}
         TT_PASSWORD: ${{ secrets.TT_PASSWORD }}
+        TT_USERNAME_SANDBOX: ${{ secrets.TT_USERNAME_SANDBOX }}
+        TT_PASSWORD_SANDBOX: ${{ secrets.TT_PASSWORD_SANDBOX }}
         TT_ACCOUNT: ${{ secrets.TT_ACCOUNT }}

README.md

@@ -21,7 +21,7 @@ A simple, reverse-engineered SDK for Tastytrade built on their (now mostly publi
 > Want to see the SDK in action? Check out [tastytrade-cli](https://github.com/tastyware/tastytrade-cli), a CLI for Tastytrade that showcases many of the SDK's features.
 
 > [!NOTE]
-> Do you use TradeStation? We're building a [brand-new SDK](https://github.com/tastyware/tradestation) for TS users, with many of the same features!
+> Want to build an advanced trading system? Check out [streaQ](https://github.com/tastyware/streaq), an async job queuing library for Python that's perfect for complex applications!
 
 ## Installation
 
@@ -66,7 +66,7 @@ Note that this is asynchronous code, so you can't run it as is unless you're usi
 ```python
 from tastytrade import Account
 
-account = Account.get_accounts(session)[0]
+account = Account.get(session)[0]
 positions = account.get_positions(session)
 print(positions[0])
 ```
@@ -75,6 +75,18 @@ print(positions[0])
 >>> CurrentPosition(account_number='5WX01234', symbol='IAU', instrument_type=<InstrumentType.EQUITY: 'Equity'>, underlying_symbol='IAU', quantity=Decimal('20'), quantity_direction='Long', close_price=Decimal('37.09'), average_open_price=Decimal('37.51'), average_yearly_market_close_price=Decimal('37.51'), average_daily_market_close_price=Decimal('37.51'), multiplier=1, cost_effect=<PriceEffect.CREDIT: 'Credit'>, is_suppressed=False, is_frozen=False, realized_day_gain=Decimal('7.888'), realized_day_gain_date=datetime.date(2023, 5, 19), realized_today=Decimal('-0.512'), realized_today_date=datetime.date(2023, 5, 19), created_at=datetime.datetime(2023, 3, 31, 14, 38, 32, 58000, tzinfo=datetime.timezone.utc), updated_at=datetime.datetime(2023, 5, 19, 16, 56, 51, 920000, tzinfo=datetime.timezone.utc), mark=None, mark_price=None, restricted_quantity=Decimal('0'), expires_at=None, fixing_price=None, deliverable_type=None)
 ```
 
+## Sync/async wrappers
+
+The code from above can be rewritten asynchronously:
+
+```python
+from tastytrade import Account
+
+account = (await Account.a_get(session))[0]
+positions = await account.a_get_positions(session)
+print(positions[0])
+```
+
 ## Placing an order
 
 ```python
@@ -83,8 +95,8 @@ from tastytrade import Account
 from tastytrade.instruments import Equity
 from tastytrade.order import NewOrder, OrderAction, OrderTimeInForce, OrderType
 
-account = Account.get_account(session, '5WX01234')
-symbol = Equity.get_equity(session, 'USO')
+account = Account.get(session, '5WX01234')
+symbol = Equity.get(session, 'USO')
 leg = symbol.build_leg(Decimal('5'), OrderAction.BUY_TO_OPEN)  # buy to open 5 shares
 
 order = NewOrder(

docs/account-streamer.rst

@@ -14,7 +14,7 @@ Here's an example of setting up an account streamer to continuously wait for eve
     from tastytrade import Account, AlertStreamer, Watchlist
 
     async with AlertStreamer(session) as streamer:
-        accounts = Account.get_accounts(session)
+        accounts = Account.get(session)
 
         # updates to balances, orders, and positions
         await streamer.subscribe_accounts(accounts)
@@ -33,7 +33,7 @@ Probably the most important information the account streamer handles is order fi
     from tastytrade.order import PlacedOrder
 
     async with AlertStreamer(session) as streamer:
-        accounts = Account.get_accounts(session)
+        accounts = Account.get(session)
         await streamer.subscribe_accounts(accounts)
 
         async for order in streamer.listen(PlacedOrder):

docs/accounts.rst

@@ -8,13 +8,13 @@ The easiest way to get an account is to grab all accounts associated with a spec
 .. code-block:: python
 
    from tastytrade import Account
-   accounts = Account.get_accounts(session)
+   accounts = Account.get(session)
 
 You can also get a specific account by its unique ID:
 
 .. code-block:: python
 
-   account = Account.get_account(session, '5WX01234')
+   account = Account.get(session, '5WX01234')
 
 The ``get_balances`` function can be used to obtain information about the current buying power and cash balance:
 
@@ -58,4 +58,4 @@ We can also view portfolio P/L over time (and even plot it!):
 
 Accounts are needed to place, replace, and delete orders. See more in :doc:`Orders <orders>`.
 
-There are many more things you can do with an ``Account`` object--check out the SDK Reference section!
+There are many more things you can do with an ``Account`` object--check out the SDK Reference section!

docs/data-streamer.rst

@@ -31,7 +31,7 @@ Once you've created the streamer, you can subscribe/unsubscribe to events, like
        await streamer.subscribe(Quote, subs_list)
        quotes = {}
        async for quote in streamer.listen(Quote):
-           quotes[quote.eventSymbol] = quote
+           quotes[quote.event_symbol] = quote
            if len(quotes) >= len(subs_list):
                break
        print(quotes)

docs/index.rst

@@ -23,7 +23,7 @@ A simple, reverse-engineered, sync/async SDK for Tastytrade built on their (now
    Want to see the SDK in action? Check out `tastytrade-cli <https://github.com/tastyware/tastytrade-cli>`_, a CLI for Tastytrade that showcases many of the SDK's features.
 
 .. note::
-   Do you use TradeStation? We're building a `brand-new SDK <https://github.com/tastyware/tradestation>`_ for TS users, with many of the same features!
+   Want to build an advanced trading system? Check out `streaQ <https://github.com/tastyware/streaq>`_, an async job queuing library for Python that's perfect for complex applications!
 
 .. toctree::
    :maxdepth: 2

docs/instruments.rst

@@ -9,11 +9,11 @@ Initialization
 
 Instruments follow a basic schema for initialization. To create an instrument(s), use the classmethods for the desired type of instrument:
 
-- ``Cryptocurrency.get_cryptocurrency()``, ``Cryptocurrency.get_cryptocurrencies()``
-- ``Equity.get_equity()``, ``Equity.get_equities()``
-- ``Future.get_future()``, ``Future.get_futures()``
-- ``Option.get_option()``, ``Option.get_options()``
-- ``FutureOption.get_future_option()``, ``FutureOption.get_future_options()``
+- ``Cryptocurrency.get()``
+- ``Equity.get()``
+- ``Future.get()``
+- ``Option.get()``
+- ``FutureOption.get()``
 
 These functions take the session object as the first parameter, and the symbol (or list of symbols) as the second.
 Note that ETFs and indices are treated as equities for the purposes of the API.
@@ -22,9 +22,9 @@ Note that ETFs and indices are treated as equities for the purposes of the API.
 
    from tastytrade.instruments import Equity, FutureOption
 
-   equities = Equity.get_equities(session, ['SPY', 'AAPL'])
+   equities = Equity.get(session, ['SPY', 'AAPL'])
    print(equities[0].is_etf, equities[0].description)
-   future_option = FutureOption.get_future_option(session, './GCJ4 OG4G4 240223P1915')
+   future_option = FutureOption.get(session, './GCJ4 OG4G4 240223P1915')
    print(future_option.exchange)
 
 >>> (False, 'APPLE INC')
@@ -57,7 +57,7 @@ Alternatively, ``NestedOptionChain`` and ``NestedFutureOptionChain`` provide a s
 
    from tastytrade.instruments import NestedOptionChain
 
-   chain = NestedOptionChain.get_chain(session, 'SPY')
+   chain = NestedOptionChain.get(session, 'SPY')
    print(chain.expirations[0].strikes[0])
 
 >>> Strike(strike_price=Decimal('437.0'), call='SPY   240417C00437000', put='SPY   240417P00437000', call_streamer_symbol='.SPY240417C437', put_streamer_symbol='.SPY240417P437')

docs/orders.rst

@@ -11,8 +11,8 @@ Placing an order
    from tastytrade.instruments import Equity
    from tastytrade.order import *
 
-   account = Account.get_account(session, '5WX01234')
-   symbol = Equity.get_equity(session, 'USO')
+   account = Account.get(session, '5WX01234')
+   symbol = Equity.get(session, 'USO')
    leg = symbol.build_leg(Decimal('5'), OrderAction.BUY_TO_OPEN)  # buy to open 5 shares
 
    order = NewOrder(
@@ -71,7 +71,7 @@ To create an OTOCO order, you need an entry point order, a stop loss order, and
    from tastytrade.instruments import Equity
    from tastytrade.order import *
 
-   symbol = Equity.get_equity(session, 'AAPL')
+   symbol = Equity.get(session, 'AAPL')
    opening = symbol.build_leg(Decimal(1), OrderAction.BUY_TO_OPEN) # buy to open 1 share
    closing = symbol.build_leg(Decimal(1), OrderAction.SELL_TO_CLOSE) # sell to close 1 share
 
@@ -103,7 +103,7 @@ An OCO order is similar, but has no trigger order. It's used to add a profit-tak
 
 .. code-block:: python
 
-   symbol = Equity.get_equity(session, 'SPY')
+   symbol = Equity.get(session, 'SPY')
    closing = symbol.build_leg(Decimal(10), OrderAction.SELL_TO_CLOSE) # sell to close 10 shares
 
    oco = NewComplexOrder(
@@ -135,7 +135,7 @@ Notional orders are slightly different from normal orders. Since the market will
 
 .. code-block:: python
 
-    symbol = Equity.get_equity(session, 'AAPL')
+    symbol = Equity.get(session, 'AAPL')
     order = NewOrder(
         time_in_force=OrderTimeInForce.DAY,
         order_type=OrderType.NOTIONAL_MARKET,

docs/sync-async.rst

@@ -10,7 +10,7 @@ Let's see how this looks:
     from tastytrade Account, Session
     session = Session(username, password)
     # using sync implementation
-    accounts = Account.get_accounts(session)
+    accounts = Account.get(session)
 
 The async implementation is similar:
 
@@ -19,7 +19,7 @@ The async implementation is similar:
     from tastytrade Account, Session
     session = Session(username, password)
     # using async implementation
-    accounts = await Account.a_get_accounts(session)
+    accounts = await Account.a_get(session)
 
 That's it! All sync methods have a parallel async method that starts with `a_`.
 

docs/watchlists.rst

@@ -1,21 +1,19 @@
 Watchlists
 ==========
 
-In this example assume ``MyWatchlist`` is an exising watchlist we want to modify.
-
 To use watchlists you'll need a production session:
 
 .. code-block:: python
 
    from tastytrade import Session
    session = Session(user, password)
 
-Now we can fetch the watchlist:
+Let's fetch an existing watchlist:
 
 .. code-block:: python
 
-   from tastytrade import Watchlist
-   watchlist = Watchlist.get_private_watchlist(session, 'MyWatchlist')
+   from tastytrade import PrivateWatchlist
+   watchlist = PrivateWatchlist.get(session, 'MyWatchlist')
    print(watchlist.watchlist_entries)
 
 >>> [{'symbol': 'AAPL', 'instrument-type': 'Equity'}, {'symbol': 'MSFT', 'instrument-type': 'Equity'}]
@@ -25,18 +23,26 @@ To add a symbol to the watchlist:
 .. code-block:: python
 
    from tastytrade.instruments import InstrumentType
-   Watchlist.add_symbol('SPY', InstrumentType.EQUITY)
-   
+   watchlist.add_symbol('SPY', InstrumentType.EQUITY)
+
 In this case, the symbol is present locally, but not remotely, so we need to update the remote list:
 
 .. code-block:: python
 
-   watchlist.update_private_watchlist(session)
+   watchlist.update(session)
 
 We can also create a new watchlist from scratch, then publish it to the Tastytrade server:
 
 .. code-block:: python
 
-   new_watchlist = Watchlist(name='NewWatchlist')
+   new_watchlist = PrivateWatchlist(name='NewWatchlist')
    new_watchlist.add_symbol('USO', InstrumentType.EQUITY)
-   new_watchlist.upload_private_watchlist(session)
+   new_watchlist.upload(session)
+
+You can also fetch public watchlists:
+
+.. code-block:: python
+
+   from tastytrade import PublicWatchlist
+   public_watchlist = PublicWatchlist.get(session, "Tom's Watchlist")
+   print(public_watchlist.watchlist_entries)