tastytrade 10.2.2__tar.gz → 10.3.0__tar.gz

{tastytrade-10.2.2 → tastytrade-10.3.0}/.github/workflows/python-app.yml

@@ -37,3 +37,5 @@ jobs:
         TT_USERNAME_SANDBOX: ${{ secrets.TT_USERNAME_SANDBOX }}
         TT_PASSWORD_SANDBOX: ${{ secrets.TT_PASSWORD_SANDBOX }}
         TT_ACCOUNT: ${{ secrets.TT_ACCOUNT }}
+        TT_REFRESH: ${{ secrets.TT_REFRESH }}
+        TT_SECRET: ${{ secrets.TT_SECRET }}

{tastytrade-10.2.2 → tastytrade-10.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tastytrade
-Version: 10.2.2
+Version: 10.3.0
 Summary: An unofficial, sync/async SDK for Tastytrade!
 Project-URL: Homepage, https://github.com/tastyware/tastytrade
 Project-URL: Documentation, https://tastyworks-api.rtfd.io

tastytrade-10.3.0/docs/sessions.rst

@@ -0,0 +1,73 @@
+Sessions
+========
+
+Creating a session
+------------------
+
+A session object is required to authenticate your requests to the Tastytrade API.
+To create a production (real) session using your normal login:
+
+.. code-block:: python
+
+   from tastytrade import Session
+   session = Session('username', 'password')
+
+A certification (test) account can be created `here <https://developer.tastytrade.com/sandbox/>`_, then used to create a session.
+
+.. code-block:: python
+
+   from tastytrade import Session
+   session = Session('username', 'password', is_test=True)
+
+You can make a session persistent by generating a remember token, which is valid for 24 hours:
+
+.. code-block:: python
+
+   session = Session('username', 'password', remember_me=True)
+   remember_token = session.remember_token
+   # remember token replaces the password for the next login
+   new_session = Session('username', remember_token=remember_token)
+
+.. note::
+   If you used a certification (test) account to create the session associated with the `remember_token`, you must set `is_test=True` when creating subsequent sessions.
+
+OAuth sessions
+--------------
+
+Tastytrade has recently added support for OAuth logins, which allow you to connect an application for the purposes of managing trades on your behalf. Apart from allowing you to connect to 3rd-party apps (or build your own), you can also build a private OAuth application, which provides better security compared to username/password authentication since you don't have to expose your login information.
+
+To get started, create a new OAuth application `here <https://my.tastytrade.com/app.html#/manage/api-access/oauth-applications>`_. You'll need to check all the scopes and save the client ID and client secret. Then, run this code:
+
+.. code-block:: python
+
+   from tastytrade.oauth import login
+
+   login()
+
+This will open up a web interface in your browser where you'll be prompted to paste your client ID and client secret. These credentials will then be used to connect your application to Tastytrade. After following the steps in your browser, you should see your refresh token in the browser and in the console, which you should save.
+
+At this point, OAuth is now setup correctly! Doing the above once is sufficient for **indefinite usage** of ``OAuthSession`` for authentication to the API, since refresh tokens never expire. From now on you can simply authenticate like so:
+
+.. code-block:: python
+
+   from tastytrade import OAuthSession
+
+   session = OAuthSession('my-client-secret', 'my-refresh-token')
+
+These session objects can be used almost anywhere you can use a normal session:
+
+.. code-block:: python
+
+   from tastytrade import Account
+
+   accounts = Account.get(session)
+
+Note that OAuth sessions make API requests using a special session token, which has a duration of only 15 minutes. However, since the refresh tokens last forever, you can call ``OAuthSession.refresh()`` to refresh the session token whenever needed. The session object will keep track of session expiration time for you to make it easier to know when to refresh:
+
+.. code-block:: python
+
+   from tastytrade.utils import now_in_new_york
+
+   if now_in_new_york() > session.session_expiration:
+       session.refresh()
+       print(Account.get(session))

{tastytrade-10.2.2 → tastytrade-10.3.0}/pyproject.toml

@@ -77,6 +77,9 @@ where = ["tastytrade"]
 [tool.ruff.lint]
 select = ["E", "F", "I"]
 
+[tool.coverage.run]
+omit = ["tastytrade/oauth.py"]
+
 [tool.pyright]
 pythonVersion = "3.9"
 include = ["tastytrade", "tests"]

{tastytrade-10.2.2 → tastytrade-10.3.0}/tastytrade/__init__.py

@@ -4,7 +4,7 @@ API_URL = "https://api.tastyworks.com"
 BACKTEST_URL = "https://backtester.vast.tastyworks.com"
 CERT_URL = "https://api.cert.tastyworks.com"
 VAST_URL = "https://vast.tastyworks.com"
-VERSION = "10.2.2"
+VERSION = "10.3.0"
 
 __version__ = VERSION
 version_str: str = f"tastyware/tastytrade:v{VERSION}"
@@ -15,12 +15,13 @@ logger.setLevel(logging.DEBUG)
 # ruff: noqa: E402
 
 from .account import Account
-from .session import Session
+from .session import OAuthSession, Session
 from .streamer import AlertStreamer, DXLinkStreamer
 
 __all__ = [
     "Account",
     "AlertStreamer",
     "DXLinkStreamer",
+    "OAuthSession",
     "Session",
 ]

{tastytrade-10.2.2 → tastytrade-10.3.0}/tastytrade/account.py

@@ -96,8 +96,10 @@ class AccountBalance(TastytradeData):
         if isinstance(data, dict):
             data = cast(dict[str, Any], data)
             key = "unsettled-cryptocurrency-fiat-amount"
-            effect: Any = data.get("unsettled-cryptocurrency-fiat-effect")
-            if effect == PriceEffect.DEBIT.value:
+            if (
+                data.get("unsettled-cryptocurrency-fiat-effect")
+                == PriceEffect.DEBIT.value
+            ):
                 data[key] = -abs(Decimal(data[key]))
         return set_sign_for(data, ["pending_cash", "buying_power_adjustment"])
 
@@ -152,8 +154,7 @@ class AccountBalanceSnapshot(TastytradeData):
         if isinstance(data, dict):
             data = cast(dict[str, Any], data)
             key = "unsettled-cryptocurrency-fiat-amount"
-            effect: Any = data.get("unsettled-cryptocurrency-fiat-effect")
-            if effect == PriceEffect.DEBIT:
+            if data.get("unsettled-cryptocurrency-fiat-effect") == PriceEffect.DEBIT:
                 data[key] = -abs(Decimal(data[key]))
         return set_sign_for(data, ["pending_cash"])
 
@@ -816,7 +817,7 @@ class Account(TastytradeData):
         session: Session,
         per_page: int = 250,
         page_offset: Optional[int] = None,
-        sort: str = "Desc",
+        sort: Literal["Asc", "Desc"] = "Desc",
         type: Optional[str] = None,
         types: Optional[list[str]] = None,
         sub_types: Optional[list[str]] = None,
@@ -911,7 +912,7 @@ class Account(TastytradeData):
         session: Session,
         per_page: int = 250,
         page_offset: Optional[int] = None,
-        sort: str = "Desc",
+        sort: Literal["Asc", "Desc"] = "Desc",
         type: Optional[str] = None,
         types: Optional[list[str]] = None,
         sub_types: Optional[list[str]] = None,
@@ -1334,7 +1335,7 @@ class Account(TastytradeData):
         statuses: Optional[list[OrderStatus]] = None,
         futures_symbol: Optional[str] = None,
         underlying_instrument_type: Optional[InstrumentType] = None,
-        sort: Optional[str] = None,
+        sort: Optional[Literal["Asc", "Desc"]] = None,
         start_at: Optional[datetime] = None,
         end_at: Optional[datetime] = None,
     ) -> list[PlacedOrder]:
@@ -1415,7 +1416,7 @@ class Account(TastytradeData):
         statuses: Optional[list[OrderStatus]] = None,
         futures_symbol: Optional[str] = None,
         underlying_instrument_type: Optional[InstrumentType] = None,
-        sort: Optional[str] = None,
+        sort: Optional[Literal["Asc", "Desc"]] = None,
         start_at: Optional[datetime] = None,
         end_at: Optional[datetime] = None,
     ) -> list[PlacedOrder]:

{tastytrade-10.2.2 → tastytrade-10.3.0}/tastytrade/backtest.py

@@ -57,7 +57,7 @@ class BacktestLeg(BacktestData):
 
     days_until_expiration: int = 45
     delta: int = 15
-    direction: Literal["buy", "sell"] = "sell"
+    direction: Literal["long", "short"] = "short"
     quantity: int = 1
     side: Literal["call", "put"] = "call"
 
@@ -159,7 +159,7 @@ class BacktestResponse(Backtest):
 
     created_at: datetime
     id: str
-    results: BacktestResults
+    results: Optional[BacktestResults] = None
     eta: Optional[int] = None
     progress: Optional[Decimal] = None
 

{tastytrade-10.2.2 → tastytrade-10.3.0}/tastytrade/market_data.py

@@ -103,6 +103,7 @@ class MarketData(TastytradeData):
     volume: Optional[Decimal] = None
     year_low_price: Optional[Decimal] = None
     year_high_price: Optional[Decimal] = None
+    open_interest: Optional[Decimal] = None
 
 
 def get_market_data(

tastytrade-10.3.0/tastytrade/oauth.py

@@ -0,0 +1,129 @@
+import re
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import parse_qs
+
+import httpx
+
+PORT = 8000
+REDIRECT_URI = f"http://localhost:{PORT}"
+SCOPES = ["read", "trade", "openid"]
+
+authorize_url = "https://my.tastytrade.com/auth.html"
+token_url = "https://api.tastyworks.com/oauth/token"
+client_id = ""
+client_secret = ""
+
+
+root_page = """
+<!DOCTYPE html>
+<html lang="en-us">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>OAuth Setup</title>
+    <!-- Favicon -->
+    <link rel="icon" type="image/x-icon" href="/static/favicon.ico">
+    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css"
+          rel="stylesheet"
+          integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH"
+          crossorigin="anonymous">
+  </head>
+  <body>
+    <div class="container position-absolute top-50 start-50 translate-middle"
+         style="width: 400px">
+      <form method="POST">
+        <div class="row mb-3">
+          <input type="text"
+                 required
+                 placeholder="Client ID"
+                 name="client_id"
+                 class="form-control">
+        </div>
+        <div class="row mb-3">
+          <input type="password"
+                 required
+                 placeholder="Client Secret"
+                 name="client_secret"
+                 class="form-control">
+        </div>
+        <div class="row mb-3">
+          <button type="submit" class="btn btn-success">Connect</button>
+        </div>
+      </form>
+    </div>
+    <script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js"
+            integrity="sha384-YvpcrYf0tY3lHB60NNkmXc5s9fDVZLESaAA55NDzOxhy9GkcIdslK1eN7N6jIeHz"
+            crossorigin="anonymous"></script>
+  </body>
+</html>
+""".encode()
+
+
+class RequestHandler(BaseHTTPRequestHandler):
+    def do_POST(self) -> None:
+        global client_id, client_secret
+        content_length = int(self.headers["Content-Length"])
+        raw = self.rfile.read(content_length)
+        data = parse_qs(raw.decode("utf-8"))
+        client_id = data["client_id"][0]
+        client_secret = data["client_secret"][0]
+
+        # Redirect to login page using API key submitted by user
+        self.send_response(302)
+        query_string = "&".join(
+            [
+                "response_type=code",
+                f"redirect_uri={REDIRECT_URI}",
+                f"client_id={data['client_id'][0]}",
+                f"scope={' '.join(SCOPES)}",
+            ]
+        )
+        url = f"{authorize_url}?{query_string}"
+        self.send_header("Location", url)
+        self.end_headers()
+
+    def do_GET(self) -> None:
+        global client_id, client_secret
+        # Serve root page with sign in link
+        if self.path == "/":
+            self.send_response(200)
+            self.send_header("Content-type", "text/html; charset=utf-8")
+            self.end_headers()
+            self.wfile.write(root_page)
+        else:
+            # Check if query path contains case insensitive "code="
+            code_match = re.search(r"code=(.+)", self.path, re.I)
+            if code_match and client_id and client_secret:
+                user_auth_code = code_match[1]
+                post_data = {
+                    "grant_type": "authorization_code",
+                    "client_id": client_id,
+                    "client_secret": client_secret,
+                    "redirect_uri": REDIRECT_URI,
+                    "code": user_auth_code,
+                }
+                response = httpx.post(token_url, data=post_data)
+                token_access = response.json()
+                refresh_token: str = token_access["refresh_token"]
+                print(refresh_token)
+
+                self.send_response(200)
+                self.send_header("Content-type", "text/html; charset=utf-8")
+                self.end_headers()
+                self.wfile.write(refresh_token.encode())
+
+
+def login(is_test: bool = False) -> None:
+    """
+    Starts a local HTTP server and opens the browser to OAuth login.
+    Designed for one-time use to get a refresh token.
+    """
+    global authorize_url, token_url
+    if is_test:
+        authorize_url = "https://cert-my.staging-tasty.works/auth.html"
+        token_url = "https://api.cert.tastyworks.com/oauth/token"
+    httpd = HTTPServer(("", PORT), RequestHandler)
+    print(f"Opening url: {REDIRECT_URI}")
+    webbrowser.open(REDIRECT_URI)
+    httpd.serve_forever()

{tastytrade-10.2.2 → tastytrade-10.3.0}/tastytrade/session.py

@@ -1,8 +1,7 @@
 from __future__ import annotations
 
 import json
-import time
-from datetime import date, datetime
+from datetime import date, datetime, timedelta
 from types import TracebackType
 from typing import Any, Optional, Union
 
@@ -11,6 +10,7 @@ from typing_extensions import Self
 
 from tastytrade import API_URL, CERT_URL, logger
 from tastytrade.utils import (
+    TZ,
     TastytradeData,
     TastytradeError,
     validate_and_parse,
@@ -300,7 +300,7 @@ class Session:
         remember_token: Optional[str] = None,
         is_test: bool = False,
         two_factor_authentication: Optional[str] = None,
-        dxfeed_tos_compliant: bool = False,
+        dxfeed_tos_compliant: bool = True,
         proxy: Optional[str] = None,
     ):
         body = {"login": login, "remember-me": remember_me}
@@ -359,15 +359,13 @@ class Session:
             else "/quote-streamer-tokens"
         )
         data = self._get(url)
-
         #: Auth token for dxfeed websocket
         self.streamer_token = data["token"]
         #: URL for dxfeed websocket
         self.dxlink_url = data["dxlink-url"]
         #: expiration for streamer token
-        exp = data.get("expires-at")
-        self.streamer_expiration = (
-            datetime.fromisoformat(exp.replace("Z", "+00:00")) if exp else None
+        self.streamer_expiration = datetime.fromisoformat(
+            data["expires-at"].replace("Z", "+00:00")
         )
 
     def __enter__(self) -> Session:
@@ -486,13 +484,10 @@ class Session:
         attrs = self.__dict__.copy()
         del attrs["async_client"]
         del attrs["sync_client"]
-        attrs["user"] = attrs["user"].model_dump()
+        if "user" in attrs:
+            attrs["user"] = attrs["user"].model_dump()
         attrs["session_expiration"] = self.session_expiration.strftime(_fmt)
-        attrs["streamer_expiration"] = (
-            self.streamer_expiration.strftime(_fmt)
-            if self.streamer_expiration
-            else None
-        )
+        attrs["streamer_expiration"] = self.streamer_expiration.strftime(_fmt)
         return json.dumps(attrs)
 
     @classmethod
@@ -501,20 +496,24 @@ class Session:
         Create a new Session object from a serialized string.
         """
         deserialized = json.loads(serialized)
-        deserialized["user"] = User(**deserialized["user"])
+        if "user" in deserialized:
+            deserialized["user"] = User(**deserialized["user"])
         self = cls.__new__(cls)
         self.__dict__ = deserialized
         base_url = CERT_URL if self.is_test else API_URL
         headers = {
             "Accept": "application/json",
             "Content-Type": "application/json",
-            "Authorization": self.session_token,
+            "Authorization": self.session_token
+            if "user" in deserialized
+            else f"Bearer {self.session_token}",
         }
         self.session_expiration = datetime.strptime(
             deserialized["session_expiration"], _fmt
         )
-        exp = deserialized.get("streamer_expiration")
-        self.streamer_expiration = datetime.strptime(exp, _fmt) if exp else None
+        self.streamer_expiration = datetime.strptime(
+            deserialized["streamer_expiration"], _fmt
+        )
         self.sync_client = Client(base_url=base_url, headers=headers, proxy=self.proxy)
         self.async_client = AsyncClient(
             base_url=base_url, headers=headers, proxy=self.proxy
@@ -522,11 +521,7 @@ class Session:
         return self
 
 
-def _now_ms() -> int:
-    return round(time.time() * 1000)
-
-
-class OAuthSession(Session):  # pragma: no cover
+class OAuthSession(Session):
     """
     Contains a managed user login which can then be used to interact with the
     remote API.
@@ -557,8 +552,6 @@ class OAuthSession(Session):  # pragma: no cover
         self.provider_secret = provider_secret
         #: Refresh token for the user
         self.refresh_token = refresh_token
-        #: Unix timestamp for when the session token expires
-        self.expires_at = 0
         # The headers to use for API requests
         headers = {
             "Accept": "application/json",
@@ -572,13 +565,28 @@ class OAuthSession(Session):  # pragma: no cover
         self.async_client = AsyncClient(
             base_url=self.sync_client.base_url, headers=headers, proxy=proxy
         )
+        #: expiration for streamer token
+        self.streamer_expiration = datetime.now(TZ)
         self.refresh()
 
+    def _streamer_refresh(self) -> None:
+        # Pull streamer tokens and urls
+        data = self._get("/api-quote-tokens")
+        # Auth token for dxfeed websocket
+        self.streamer_token = data["token"]
+        # URL for dxfeed websocket
+        self.dxlink_url = data["dxlink-url"]
+        self.streamer_expiration = datetime.fromisoformat(
+            data["expires-at"].replace("Z", "+00:00")
+        )
+
     def refresh(self) -> None:
         """
         Refreshes the acccess token using the stored refresh token.
+        Also refreshes the streamer token if necessary.
         """
-        response = self.sync_client.post(
+        request = self.sync_client.build_request(
+            "POST",
             "/oauth/token",
             json={
                 "grant_type": "refresh_token",
@@ -586,23 +594,32 @@ class OAuthSession(Session):  # pragma: no cover
                 "refresh_token": self.refresh_token,
             },
         )
+        # Don't send the Authorization header for this request
+        request.headers.pop("Authorization", None)
+        response = self.sync_client.send(request)
         validate_response(response)
         data = response.json()
-        # update the relevant tokens
+        #: The session token used to authenticate requests
         self.session_token = data["access_token"]
-        token_lifetime = data.get("expires_in", 900) * 1000
-        self.expires_at = _now_ms() + token_lifetime
+        token_lifetime: int = data.get("expires_in", 900)
+        #: expiration for session token
+        self.session_expiration = datetime.now(TZ) + timedelta(seconds=token_lifetime)
         logger.debug(f"Refreshed token, expires in {token_lifetime}ms")
         auth_headers = {"Authorization": f"Bearer {self.session_token}"}
         # update the httpx clients with the new token
         self.sync_client.headers.update(auth_headers)
         self.async_client.headers.update(auth_headers)
+        # update the streamer token if necessary
+        if self.streamer_expiration < self.session_expiration:
+            self._streamer_refresh()
 
     async def a_refresh(self) -> None:
         """
         Refreshes the acccess token using the stored refresh token.
+        Also refreshes the streamer token if necessary.
         """
-        response = await self.async_client.post(
+        request = self.async_client.build_request(
+            "POST",
             "/oauth/token",
             json={
                 "grant_type": "refresh_token",
@@ -610,45 +627,28 @@ class OAuthSession(Session):  # pragma: no cover
                 "refresh_token": self.refresh_token,
             },
         )
+        # Don't send the Authorization header for this request
+        request.headers.pop("Authorization", None)
+        response = await self.async_client.send(request)
         validate_response(response)
         data = response.json()
         # update the relevant tokens
         self.session_token = data["access_token"]
-        token_lifetime = data.get("expires_in", 900) * 1000
-        self.expires_at = _now_ms() + token_lifetime
+        token_lifetime: int = data.get("expires_in", 900)
+        self.session_expiration = datetime.now(TZ) + timedelta(token_lifetime)
         logger.debug(f"Refreshed token, expires in {token_lifetime}ms")
         auth_headers = {"Authorization": f"Bearer {self.session_token}"}
         # update the httpx clients with the new token
         self.sync_client.headers.update(auth_headers)
         self.async_client.headers.update(auth_headers)
-
-    def serialize(self) -> str:
-        """
-        Serializes the session to a string, useful for storing
-        a session for later use.
-        Could be used with pickle, Redis, etc.
-        """
-        attrs = self.__dict__.copy()
-        del attrs["async_client"]
-        del attrs["sync_client"]
-        return json.dumps(attrs)
-
-    @classmethod
-    def deserialize(cls, serialized: str) -> Self:
-        """
-        Create a new Session object from a serialized string.
-        """
-        deserialized = json.loads(serialized)
-        self = cls.__new__(cls)
-        self.__dict__ = deserialized
-        base_url = CERT_URL if self.is_test else API_URL
-        headers = {
-            "Accept": "application/json",
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {self.session_token}",
-        }
-        self.sync_client = Client(base_url=base_url, headers=headers, proxy=self.proxy)
-        self.async_client = AsyncClient(
-            base_url=base_url, headers=headers, proxy=self.proxy
-        )
-        return self
+        # update the streamer token if necessary
+        if self.streamer_expiration < self.session_expiration:
+            # Pull streamer tokens and urls
+            data = await self._a_get("/api-quote-tokens")
+            # Auth token for dxfeed websocket
+            self.streamer_token = data["token"]
+            # URL for dxfeed websocket
+            self.dxlink_url = data["dxlink-url"]
+            self.streamer_expiration = datetime.fromisoformat(
+                data["expires-at"].replace("Z", "+00:00")
+            )

{tastytrade-10.2.2 → tastytrade-10.3.0}/tastytrade/streamer.py

@@ -252,6 +252,7 @@ class AlertStreamer:
         self._reconnect_task: Optional[asyncio.Task[None]] = None
         self._heartbeat_task: Optional[asyncio.Task[None]] = None
         self._closing = False
+        self._tasks: set[asyncio.Task[Any]] = set()
 
     async def __aenter__(self) -> AlertStreamer:
         time_out = 100
@@ -278,17 +279,18 @@ class AlertStreamer:
         """
         Closes the websocket connection and cancels the pending tasks.
         """
-        self._closing = True
-        self._connect_task.cancel()
-        tasks = [self._connect_task]
-        if self._heartbeat_task and not self._heartbeat_task.done():
-            self._heartbeat_task.cancel()
-            tasks.append(self._heartbeat_task)
-        if self._reconnect_task and not self._reconnect_task.done():
-            self._reconnect_task.cancel()
-            tasks.append(self._reconnect_task)
-        await asyncio.gather(*tasks)
-        await self._websocket.wait_closed()  # type: ignore
+        if not self._closing:  # can only be called once
+            self._closing = True
+            self._connect_task.cancel()
+            tasks = [self._connect_task]
+            if self._heartbeat_task and not self._heartbeat_task.done():
+                self._heartbeat_task.cancel()
+                tasks.append(self._heartbeat_task)
+            if self._reconnect_task and not self._reconnect_task.done():
+                self._reconnect_task.cancel()
+                tasks.append(self._reconnect_task)
+            await asyncio.gather(*tasks)
+            await self._websocket.wait_closed()  # type: ignore
 
     async def _connect(self) -> None:
         """
@@ -316,11 +318,11 @@ class AlertStreamer:
                 logger.error(f"Websocket connection closed with {e}")
             except asyncio.CancelledError:
                 logger.debug("Websocket interrupted, cancelling main loop.")
-                if not self._closing:
-                    await self.close()
-                return
+                return await self.close()
             finally:
-                asyncio.create_task(self.disconnect_fn(self, *self.disconnect_args))
+                self._tasks.add(  # prevent garbage collection
+                    asyncio.create_task(self.disconnect_fn(self, *self.disconnect_args))
+                )
             logger.debug("Websocket connection closed, retrying...")
             reconnecting = True
 
@@ -488,6 +490,7 @@ class DXLinkStreamer:
         self._reconnect_task: Optional[asyncio.Task[None]] = None
         self._closing = False
         self._websocket: ClientConnection
+        self._tasks: set[asyncio.Task[Any]] = set()
 
     async def __aenter__(self) -> DXLinkStreamer:
         self._connect_task = asyncio.create_task(self._connect())
@@ -515,17 +518,18 @@ class DXLinkStreamer:
         """
         Closes the websocket connection and cancels the heartbeat task.
         """
-        self._closing = True
-        self._connect_task.cancel()
-        tasks = [self._connect_task]
-        if self._heartbeat_task:
-            self._heartbeat_task.cancel()
-            tasks.append(self._heartbeat_task)
-        if self._reconnect_task is not None and not self._reconnect_task.done():
-            self._reconnect_task.cancel()
-            tasks.append(self._reconnect_task)
-        await asyncio.gather(*tasks)
-        await self._websocket.wait_closed()
+        if not self._closing:  # can only be called once
+            self._closing = True
+            self._connect_task.cancel()
+            tasks = [self._connect_task]
+            if self._heartbeat_task:
+                self._heartbeat_task.cancel()
+                tasks.append(self._heartbeat_task)
+            if self._reconnect_task is not None and not self._reconnect_task.done():
+                self._reconnect_task.cancel()
+                tasks.append(self._reconnect_task)
+            await asyncio.gather(*tasks)
+            await self._websocket.wait_closed()
 
     async def _connect(self) -> None:
         """
@@ -592,8 +596,7 @@ class DXLinkStreamer:
                         pass
                     elif message["type"] == "ERROR":
                         logger.error(f"Fatal streamer error: {message['message']}")
-                        await self.close()
-                        return
+                        return await self.close()
                     else:
                         logger.error(f"Unknown message: {message}")
             except ConnectionClosed as e:
@@ -603,15 +606,14 @@ class DXLinkStreamer:
                         "Subscription message too long! Try reducing the number of "
                         "symbols."
                     )
-                    await self.close()
-                    return
+                    return await self.close()
             except asyncio.CancelledError:
                 logger.debug("Websocket interrupted, cancelling main loop.")
-                if not self._closing:
-                    await self.close()
-                return
+                return await self.close()
             finally:
-                asyncio.create_task(self.disconnect_fn(self, *self.disconnect_args))
+                self._tasks.add(  # prevent garbage collection
+                    asyncio.create_task(self.disconnect_fn(self, *self.disconnect_args))
+                )
             logger.debug("Websocket connection closed, retrying...")
             reconnecting = True
 
@@ -817,7 +819,6 @@ class DXLinkStreamer:
             the width of each candle in time, e.g. '15s', '5m', '1h', '3d',
             '1w', '1mo'
         :param start_time: starting time for the data range
-        :param end_time: ending time for the data range
         :param extended_trading_hours: whether to include extended trading
         :param refresh_interval:
             Time in seconds between fetching new events from dxfeed for this event type.
@@ -828,6 +829,7 @@ class DXLinkStreamer:
         cls_str = "Candle"
         if self._subscription_state[cls_str] != "CHANNEL_OPENED":
             await self._channel_request(cls_str, refresh_interval)
+        ts = int(start_time.timestamp() * 1000)
         message = {
             "type": "FEED_SUBSCRIPTION",
             "channel": self._channels[cls_str],
@@ -839,7 +841,7 @@ class DXLinkStreamer:
                         else f"{ticker}{{={interval},tho=true}}"
                     ),
                     "type": "Candle",
-                    "fromTime": int(start_time.timestamp() * 1000),
+                    "fromTime": ts,
                 }
                 for ticker in symbols
             ],

{tastytrade-10.2.2 → tastytrade-10.3.0}/tastytrade/utils.py

@@ -1,6 +1,7 @@
 from datetime import date, datetime, timedelta
 from decimal import Decimal
 from enum import Enum
+from json import JSONDecodeError
 from typing import Any, Optional, cast
 from zoneinfo import ZoneInfo
 
@@ -50,8 +51,7 @@ def is_market_open_on(day: Optional[date] = None) -> bool:
 
     :return: whether the market opens on given day
     """
-    if not day:
-        day = today_in_new_york()
+    day = day or today_in_new_york()
     date_range = NYSE.valid_days(day, day)
     return not date_range.empty
 
@@ -65,10 +65,7 @@ def get_third_friday(day: Optional[date] = None) -> date:
 
     :return: the associated monthly
     """
-    if not day:
-        day = today_in_new_york()
-    day = day.replace(day=1)
-    day += timedelta(weeks=2)
+    day = (day or today_in_new_york()).replace(day=1) + timedelta(weeks=2)
     while day.weekday() != 4:  # Friday
         day += timedelta(days=1)
     return day
@@ -105,10 +102,7 @@ def get_future_fx_monthly(day: Optional[date] = None) -> date:
 
     :return: the associated monthly
     """
-    if not day:
-        day = today_in_new_york()
-    day = day.replace(day=1)
-    day += timedelta(weeks=1)
+    day = (day or today_in_new_york()).replace(day=1) + timedelta(weeks=1)
     while day.weekday() != 2:  # Wednesday
         day += timedelta(days=1)
     while day.weekday() != 4:  # Friday
@@ -127,8 +121,7 @@ def get_future_treasury_monthly(day: Optional[date] = None) -> date:
 
     :return: the associated monthly
     """
-    if not day:
-        day = today_in_new_york()
+    day = day or today_in_new_york()
     last_day = _get_last_day_of_month(day)
     first_day = last_day.replace(day=1)
     valid_range: list[date] = [d.date() for d in NYSE.valid_days(first_day, last_day)]
@@ -151,8 +144,7 @@ def get_future_metal_monthly(day: Optional[date] = None) -> date:
 
     :return: the associated monthly
     """
-    if not day:
-        day = today_in_new_york()
+    day = day or today_in_new_york()
     last_day = _get_last_day_of_month(day)
     first_day = last_day.replace(day=1)
     valid_range: list[date] = [d.date() for d in NYSE.valid_days(first_day, last_day)]
@@ -173,8 +165,7 @@ def get_future_grain_monthly(day: Optional[date] = None) -> date:
 
     :return: the associated monthly
     """
-    if not day:
-        day = today_in_new_york()
+    day = day or today_in_new_york()
     last_day = _get_last_day_of_month(day)
     first_day = last_day.replace(day=1)
     valid_range: list[date] = [d.date() for d in NYSE.valid_days(first_day, last_day)]
@@ -195,9 +186,7 @@ def get_future_oil_monthly(day: Optional[date] = None) -> date:
 
     :return: the associated monthly
     """
-    if not day:
-        day = today_in_new_york()
-    last_day = day.replace(day=25)
+    last_day = (day or today_in_new_york()).replace(day=25)
     first_day = last_day.replace(day=1)
     valid_range: list[date] = [d.date() for d in NYSE.valid_days(first_day, last_day)]
     return valid_range[-7]
@@ -213,8 +202,7 @@ def get_future_index_monthly(day: Optional[date] = None) -> date:
 
     :return: the associated monthly
     """
-    if not day:
-        day = today_in_new_york()
+    day = day or today_in_new_york()
     last_day = _get_last_day_of_month(day)
     first_day = last_day.replace(day=1)
     valid_range: list[date] = [d.date() for d in NYSE.valid_days(first_day, last_day)]
@@ -262,29 +250,29 @@ def validate_response(response: Response) -> None:
     :param response: response to check for errors
     """
     if response.status_code // 100 != 2:
-        json: dict[str, Any] = response.json()
-        content = json.get("error")
-        if not content:
+        try:
+            json: dict[str, Any] = response.json()
+        except JSONDecodeError as e:
+            raise TastytradeError(f"Couldn't parse response: {response.text}") from e
+        if not (content := json.get("error")):
             raise TastytradeError(f"Couldn't parse response: {json}")
-        error_message = f"{content['code']}: {content['message']}"
-        errors = content.get("errors")
-        if errors is not None:
-            for error in errors:
-                if "code" in error:
-                    error_message += f"\n{error['code']}: {error['message']}"
-                else:
-                    error_message += f"\n{error['domain']}: {error['reason']}"
+        errors = content.get("errors") or [content]
+        message = ""
+        for error in errors:
+            if "code" in error:
+                message += f"{error['code']}: {error['message']}\n"
+            else:
+                message += f"{error['domain']}: {error['reason']}\n"
 
-        raise TastytradeError(error_message)
+        raise TastytradeError(message)
 
 
 def validate_and_parse(response: Response) -> dict[str, Any]:
     validate_response(response)
     json = response.json()
-    data: Optional[dict[str, Any]] = json.get("data")
-    if data is None:
+    if not (data := json.get("data")):
         raise TastytradeError(f"No data present in response: {json}")
-    return data
+    return cast(dict[str, Any], data)
 
 
 def get_sign(value: Optional[Decimal]) -> Optional[PriceEffect]:
@@ -304,7 +292,6 @@ def set_sign_for(data: Any, properties: list[str]) -> Any:
         data = cast(dict[str, Any], data)
         for property in properties:
             key = _dasherize(property)
-            effect = data.get(f"{key}-effect")
-            if effect == PriceEffect.DEBIT:
+            if data.get(f"{key}-effect") == PriceEffect.DEBIT:
                 data[key] = -abs(Decimal(data[key]))
     return data

{tastytrade-10.2.2 → tastytrade-10.3.0}/tests/test_backtest.py

@@ -17,7 +17,10 @@ async def test_backtest_simple(session: Session):
         symbol="SPY",
         entry_conditions=BacktestEntry(),
         exit_conditions=BacktestExit(at_days_to_expiration=21),
-        legs=[BacktestLeg(), BacktestLeg(side="put")],
+        legs=[
+            BacktestLeg(direction="short"),
+            BacktestLeg(direction="long", side="put"),
+        ],
         start_date=today_in_new_york() - timedelta(days=365),
     )
     results = [r async for r in backtest_session.run(backtest)]

{tastytrade-10.2.2 → tastytrade-10.3.0}/tests/test_instruments.py

@@ -147,7 +147,10 @@ async def test_get_option_chain_async(session: Session):
     chain = await a_get_option_chain(session, "SPY")
     assert chain != {}
     for options in chain.values():
-        await Option.a_get(session, options[0].symbol)
+        single = await Option.a_get(session, options[0].symbol)
+        multiple = await Option.a_get(session, [options[0].symbol, options[1].symbol])
+        assert isinstance(single, Option)
+        assert isinstance(multiple, list)
         break
 
 
@@ -155,7 +158,14 @@ def test_get_option_chain(session: Session):
     chain = get_option_chain(session, "SPY")
     assert chain != {}
     for options in chain.values():
-        Option.get(session, options[0].symbol)
+        single = Option.get(session, options[0].symbol)
+        # test setting symbol
+        old = single.streamer_symbol
+        single._set_streamer_symbol()
+        assert single.streamer_symbol == old
+        multiple = Option.get(session, [options[0].symbol, options[1].symbol])
+        assert isinstance(single, Option)
+        assert isinstance(multiple, list)
         break
 
 

{tastytrade-10.2.2 → tastytrade-10.3.0}/tests/test_session.py

@@ -3,7 +3,7 @@ import os
 import pytest
 from proxy import TestCase
 
-from tastytrade import Session
+from tastytrade import Account, OAuthSession, Session
 
 
 def test_get_customer(session: Session):
@@ -56,3 +56,26 @@ def test_cert_session():
     assert username and password
     session = Session(username, password, is_test=True)
     session.destroy()
+
+
+@pytest.fixture(scope="module")
+async def oauth(aiolib: str) -> OAuthSession:
+    refresh = os.getenv("TT_REFRESH")
+    secret = os.getenv("TT_SECRET")
+    assert refresh and secret
+    return OAuthSession(secret, refresh)
+
+
+def test_oauth_refresh(oauth: OAuthSession):
+    pass
+
+
+def test_oauth_serialization(oauth: OAuthSession):
+    session_str = oauth.serialize()
+    session2 = OAuthSession.deserialize(session_str)
+    print(oauth.session_token == session2.session_token)
+    Account.get(session2)
+
+
+async def test_oauth_refresh_async(oauth: OAuthSession):
+    await oauth.a_refresh()

tastytrade-10.2.2/docs/sessions.rst

@@ -1,32 +0,0 @@
-Sessions
-========
-
-Creating a session
-------------------
-
-A session object is required to authenticate your requests to the Tastytrade API.
-To create a production (real) session using your normal login:
-
-.. code-block:: python
-
-   from tastytrade import Session
-   session = Session('username', 'password')
-
-A certification (test) account can be created `here <https://developer.tastytrade.com/sandbox/>`_, then used to create a session.
-
-.. code-block:: python
-
-   from tastytrade import Session
-   session = Session('username', 'password', is_test=True)
-
-You can make a session persistent by generating a remember token, which is valid for 24 hours:
-
-.. code-block:: python
-
-   session = Session('username', 'password', remember_me=True)
-   remember_token = session.remember_token
-   # remember token replaces the password for the next login
-   new_session = Session('username', remember_token=remember_token)
-
-.. note::
-   If you used a certification (test) account to create the session associated with the `remember_token`, you must set `is_test=True` when creating subsequent sessions.