schwabdev 2.2.0__tar.gz → 2.2.2__tar.gz

{schwabdev-2.2.0 → schwabdev-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schwabdev
-Version: 2.2.0
+Version: 2.2.2
 Summary: An easy and lightweight wrapper for using the Charles Schwab API.
 Author: Tyler Bowers
 Author-email: tylerebowers@gmail.com
@@ -19,6 +19,8 @@ Classifier: Natural Language :: English
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: requests
+Requires-Dist: websockets
 
 # Schwab-API-Python
 ![PyPI - Version](https://img.shields.io/pypi/v/schwabdev) ![Discord](https://img.shields.io/discord/1076596998150561873?logo=discord) ![PyPI - Downloads](https://img.shields.io/pypi/dm/schwabdev) [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/donate/?business=8VDFKHMBFSC2Q&no_recurring=0&currency_code=USD) ![YouTube Video Views](https://img.shields.io/youtube/views/kHbom0KIJwc?style=flat&logo=youtube)  
@@ -54,6 +56,7 @@ print(client.account_linked().json()) #make api calls
  - Functions for all api functions (examples in `examples/api_demo.py`)
  - Stream real-time data with a customizable response handler (examples in `examples/stream_demo.py`)
  ### TBD 
+ - Paper trading client
  - Automatic refresh token updates. (Waiting for Schwab implementation)
 ### Notes
 The schwabdev folder contains code for main operations:     

{schwabdev-2.2.0 → schwabdev-2.2.2}/README.md

@@ -32,6 +32,7 @@ print(client.account_linked().json()) #make api calls
  - Functions for all api functions (examples in `examples/api_demo.py`)
  - Stream real-time data with a customizable response handler (examples in `examples/stream_demo.py`)
  ### TBD 
+ - Paper trading client
  - Automatic refresh token updates. (Waiting for Schwab implementation)
 ### Notes
 The schwabdev folder contains code for main operations:     

{schwabdev-2.2.0 → schwabdev-2.2.2}/schwabdev/api.py

@@ -1,13 +1,12 @@
 import json
 import time
 import base64
+import datetime
 import requests
 import threading
 import webbrowser
 import urllib.parse
 from .stream import Stream
-from datetime import datetime
-
 
 class Client:
 
@@ -75,8 +74,8 @@ class Client:
             self._access_token_issued = at_issued
             self._refresh_token_issued = rt_issued
             if self.verbose:
-                print(self._access_token_issued.strftime("Access token last updated: %Y-%m-%d %H:%M:%S") + f" (expires in {self._access_token_timeout - (datetime.now() - self._access_token_issued).seconds} seconds)")
-                print(self._refresh_token_issued.strftime("Refresh token last updated: %Y-%m-%d %H:%M:%S") + f" (expires in {self._refresh_token_timeout - (datetime.now() - self._refresh_token_issued).days} days)")
+                print(self._access_token_issued.strftime("Access token last updated: %Y-%m-%d %H:%M:%S") + f" (expires in {self._access_token_timeout - (datetime.datetime.now(datetime.timezone.utc) - self._access_token_issued).seconds} seconds)")
+                print(self._refresh_token_issued.strftime("Refresh token last updated: %Y-%m-%d %H:%M:%S") + f" (expires in {self._refresh_token_timeout - (datetime.datetime.now(datetime.timezone.utc) - self._refresh_token_issued).days} days)")
             # check if tokens need to be updated and update if needed
             self.update_tokens()
         else:
@@ -98,7 +97,7 @@ class Client:
             print("Warning: Tokens will not be updated automatically.")
 
         if self.verbose:
-            print("Initialization Complete")
+            print("Schwabdev Client Initialization Complete")
 
     def update_tokens(self, force=False):
         """
@@ -106,11 +105,11 @@ class Client:
         :param force: force update of refresh token (also updates access token)
         :type force: bool
         """
-        if (datetime.now() - self._refresh_token_issued).days >= (self._refresh_token_timeout - 1) or force:  # check if we need to update refresh (and access) token
+        if (datetime.datetime.now(datetime.timezone.utc) - self._refresh_token_issued).days >= (self._refresh_token_timeout - 1) or force:  # check if we need to update refresh (and access) token
             print("The refresh token has expired, please update!")
             self._update_refresh_token()
-        elif ((datetime.now() - self._access_token_issued).days >= 1) or (
-                (datetime.now() - self._access_token_issued).seconds > (self._access_token_timeout - 61)):  # check if we need to update access token
+        elif ((datetime.datetime.now(datetime.timezone.utc) - self._access_token_issued).days >= 1) or (
+                (datetime.datetime.now(datetime.timezone.utc) - self._access_token_issued).seconds > (self._access_token_timeout - 61)):  # check if we need to update access token
             if self.verbose: print("The access token has expired, updating automatically.")
             self._update_access_token()
 
@@ -129,7 +128,7 @@ class Client:
             response = self._post_oauth_token('refresh_token', token_dictionary_old.get("refresh_token"))
             if response.ok:
                 # get and update to the new access token
-                self._access_token_issued = datetime.now()
+                self._access_token_issued = datetime.datetime.now(datetime.timezone.utc)
                 self._refresh_token_issued = refresh_token_issued
                 new_td = response.json()
                 self.access_token = new_td.get("access_token")
@@ -140,6 +139,7 @@ class Client:
                     print(f"Access token updated: {self._access_token_issued}")
                 break
             else:
+                print(response.text)
                 print(f"Could not get new access token ({i+1} of 3).")
                 time.sleep(10)
 
@@ -159,7 +159,7 @@ class Client:
         response = self._post_oauth_token('authorization_code', code)
         if response.ok:
             # update token file and variables
-            self._access_token_issued = self._refresh_token_issued = datetime.now()
+            self._access_token_issued = self._refresh_token_issued = datetime.datetime.now(datetime.timezone.utc)
             new_td = response.json()
             self.access_token = new_td.get("access_token")
             self.refresh_token = new_td.get("refresh_token")
@@ -168,6 +168,7 @@ class Client:
             self._write_tokens_file(self._access_token_issued, self._refresh_token_issued, new_td)
             if self.verbose: print("Refresh and Access tokens updated")
         else:
+            print(response.text)
             print("Could not get new refresh and access tokens, check these:\n    1. App status is "
                   "\"Ready For Use\".\n    2. App key and app secret are valid.\n    3. You pasted the "
                   "whole url within 30 seconds. (it has a quick expiration)")
@@ -198,9 +199,9 @@ class Client:
         """
         Writes token file
         :param at_issued: access token issued
-        :type at_issued: datetime
+        :type at_issued: datetime.pyi
         :param rt_issued: refresh token issued
-        :type rt_issued: datetime
+        :type rt_issued: datetime.pyi
         :param token_dictionary: token dictionary
         :type token_dictionary: dict
         """
@@ -218,12 +219,12 @@ class Client:
         """
         Reads token file
         :return: access token issued, refresh token issued, token dictionary
-        :rtype: datetime, datetime, dict
+        :rtype: datetime.pyi, datetime.pyi, dict
         """
         try:
             with open(self._tokens_file, 'r') as f:
                 d = json.load(f)
-                return datetime.fromisoformat(d.get("access_token_issued")), datetime.fromisoformat(d.get("refresh_token_issued")), d.get("token_dictionary")
+                return datetime.datetime.fromisoformat(d.get("access_token_issued")), datetime.datetime.fromisoformat(d.get("refresh_token_issued")), d.get("token_dictionary")
         except Exception as e:
             print(e)
             return None, None, None
@@ -243,8 +244,8 @@ class Client:
     def _time_convert(self, dt=None, form="8601"):
         """
         Convert time to the correct format, passthrough if a string, preserve None if None for params parser
-        :param dt: datetime object to convert
-        :type dt: datetime
+        :param dt: datetime.pyi object to convert
+        :type dt: datetime.pyi
         :param form: what to convert input to
         :type form: str
         :return: converted time or passthrough
@@ -253,7 +254,7 @@ class Client:
         if dt is None or isinstance(dt, str):
             return dt
         elif form == "8601":  # assume datetime object from here on
-            return f'{dt.isoformat()[:-3]}Z'
+            return f'{dt.isoformat()[:-9]}Z'
         elif form == "epoch":
             return int(dt.timestamp())
         elif form == "epoch_ms":
@@ -263,7 +264,7 @@ class Client:
         else:
             return dt
 
-    def _format_list(self, l):
+    def _format_list(self, l: list | str | None):
         """
         Convert python list to string or passthough if already a string i.e ["a", "b"] -> "a,b"
         :param l: list to convert
@@ -284,7 +285,7 @@ class Client:
     Accounts and Trading Production
     """
 
-    def account_linked(self):
+    def account_linked(self) -> requests.Response:
         """
         Account numbers in plain text cannot be used outside of headers or request/response bodies. As the first step consumers must invoke this service to retrieve the list of plain text/encrypted value pairs, and use encrypted account values for all subsequent calls for any accountNumber request.
         :return: All linked account numbers and hashes
@@ -294,7 +295,7 @@ class Client:
                             headers={'Authorization': f'Bearer {self.access_token}'},
                             timeout=self.timeout)
 
-    def account_details_all(self, fields=None):
+    def account_details_all(self, fields=None) -> requests.Response:
         """
         All the linked account information for the user logged in. The balances on these accounts are displayed by default however the positions on these accounts will be displayed based on the "positions" flag.
         :param fields: fields to return (options: "positions")
@@ -307,7 +308,7 @@ class Client:
                             params=self._params_parser({'fields': fields}),
                             timeout=self.timeout)
 
-    def account_details(self, accountHash, fields=None):
+    def account_details(self, accountHash: str, fields=None) -> requests.Response:
         """
         Specific account information with balances and positions. The balance information on these accounts is displayed by default but Positions will be returned based on the "positions" flag.
         :param accountHash: account hash from account_linked()
@@ -322,15 +323,15 @@ class Client:
                             params=self._params_parser({'fields': fields}),
                             timeout=self.timeout)
 
-    def account_orders(self, accountHash, fromEnteredTime, toEnteredTime, maxResults=None, status=None):
+    def account_orders(self, accountHash: str, fromEnteredTime: 'datetime | str', toEnteredTime: 'datetime | str', maxResults=None, status=None) -> requests.Response:
         """
         All orders for a specific account. Orders retrieved can be filtered based on input parameters below. Maximum date range is 1 year.
         :param accountHash: account hash from account_linked()
         :type accountHash: str
         :param fromEnteredTime: from entered time
-        :type fromEnteredTime: datetime | str
+        :type fromEnteredTime: datetime.pyi | str
         :param toEnteredTime: to entered time
-        :type toEnteredTime: datetime | str
+        :type toEnteredTime: datetime.pyi | str
         :param maxResults: maximum number of results
         :type maxResults: int
         :param status: status ("AWAITING_PARENT_ORDER"|"AWAITING_CONDITION"|"AWAITING_STOP_CONDITION"|"AWAITING_MANUAL_REVIEW"|"ACCEPTED"|"AWAITING_UR_OUT"|"PENDING_ACTIVATION"|"QUEUED"|"WORKING"|"REJECTED"|"PENDING_CANCEL"|"CANCELED"|"PENDING_REPLACE"|"REPLACED"|"FILLED"|"EXPIRED"|"NEW"|"AWAITING_RELEASE_TIME"|"PENDING_ACKNOWLEDGEMENT"|"PENDING_RECALL"|"UNKNOWN")
@@ -345,7 +346,7 @@ class Client:
                                  'toEnteredTime': self._time_convert(toEnteredTime, "8601"), 'status': status}),
                             timeout=self.timeout)
 
-    def order_place(self, accountHash, order):
+    def order_place(self, accountHash: str, order: dict) -> requests.Response:
         """
         Place an order for a specific account.
         :param accountHash: account hash from account_linked()
@@ -361,13 +362,13 @@ class Client:
                              json=order,
                              timeout=self.timeout)
 
-    def order_details(self, accountHash, orderId):
+    def order_details(self, accountHash:str, orderId: int | str) -> requests.Response:
         """
         Get a specific order by its ID, for a specific account
         :param accountHash: account hash from account_linked()
         :type accountHash: str
         :param orderId: order id
-        :type orderId: str
+        :type orderId: int | str
         :return: order details
         :rtype: request.Response
         """
@@ -375,13 +376,13 @@ class Client:
                             headers={'Authorization': f'Bearer {self.access_token}'},
                             timeout=self.timeout)
 
-    def order_cancel(self, accountHash, orderId):
+    def order_cancel(self, accountHash: str, orderId: int | str) -> requests.Response:
         """
         Cancel a specific order by its ID, for a specific account
         :param accountHash: account hash from account_linked()
         :type accountHash: str
         :param orderId: order id
-        :type orderId: str
+        :type orderId: str|int
         :return: response code
         :rtype: request.Response
         """
@@ -389,13 +390,13 @@ class Client:
                                headers={'Authorization': f'Bearer {self.access_token}'},
                                timeout=self.timeout)
 
-    def order_replace(self, accountHash, orderId, order):
+    def order_replace(self, accountHash: str, orderId: int | str, order: dict) -> requests.Response:
         """
         Replace an existing order for an account. The existing order will be replaced by the new order. Once replaced, the old order will be canceled and a new order will be created.
         :param accountHash: account hash from account_linked()
         :type accountHash: str
         :param orderId: order id
-        :type orderId: str
+        :type orderId: str|int
         :param order: order dictionary, examples in Schwab docs
         :type order: dict
         :return: response code
@@ -407,13 +408,13 @@ class Client:
                             json=order,
                             timeout=self.timeout)
 
-    def account_orders_all(self, fromEnteredTime, toEnteredTime, maxResults=None, status=None):
+    def account_orders_all(self, fromEnteredTime: 'datetime | str', toEnteredTime: 'datetime | str', maxResults=None, status=None) -> requests.Response:
         """
         Get all orders for all accounts
         :param fromEnteredTime: start date
-        :type fromEnteredTime: datetime | str
+        :type fromEnteredTime: datetime.pyi | str
         :param toEnteredTime: end date
-        :type toEnteredTime: datetime | str
+        :type toEnteredTime: datetime.pyi | str
         :param maxResults: maximum number of results (set to None for default 3000)
         :type maxResults: int
         :param status: status ("AWAITING_PARENT_ORDER"|"AWAITING_CONDITION"|"AWAITING_STOP_CONDITION"|"AWAITING_MANUAL_REVIEW"|"ACCEPTED"|"AWAITING_UR_OUT"|"PENDING_ACTIVATION"|"QUEUED"|"WORKING"|"REJECTED"|"PENDING_CANCEL"|"CANCELED"|"PENDING_REPLACE"|"REPLACED"|"FILLED"|"EXPIRED"|"NEW"|"AWAITING_RELEASE_TIME"|"PENDING_ACKNOWLEDGEMENT"|"PENDING_RECALL"|"UNKNOWN")
@@ -429,22 +430,22 @@ class Client:
                             timeout=self.timeout)
 
     """
-    def order_preview(self, accountHash, orderObject):
+    def order_preview(self, accountHash, orderObject) -> requests.Response:
         #COMING SOON (waiting on Schwab)
         return requests.post(f'{self._base_api_url}/trader/v1/accounts/{accountHash}/previewOrder',
                              headers={'Authorization': f'Bearer {self.access_token}',
                                       "Content-Type": "application.json"}, data=orderObject)
     """
 
-    def transactions(self, accountHash, startDate, endDate, types, symbol=None):
+    def transactions(self, accountHash: str, startDate: 'datetime | str', endDate: 'datetime | str', types: str, symbol=None) -> requests.Response:
         """
         All transactions for a specific account. Maximum number of transactions in response is 3000. Maximum date range is 1 year.
         :param accountHash: account hash number
         :type accountHash: str
         :param startDate: start date
-        :type startDate: datetime | str
+        :type startDate: datetime.pyi | str
         :param endDate: end date
-        :type endDate: datetime | str
+        :type endDate: datetime.pyi | str
         :param types: transaction type ("TRADE, RECEIVE_AND_DELIVER, DIVIDEND_OR_INTEREST, ACH_RECEIPT, ACH_DISBURSEMENT, CASH_RECEIPT, CASH_DISBURSEMENT, ELECTRONIC_FUND, WIRE_OUT, WIRE_IN, JOURNAL, MEMORANDUM, MARGIN_CALL, MONEY_MARKET, SMA_ADJUSTMENT")
         :type types: str
         :param symbol: symbol
@@ -458,13 +459,13 @@ class Client:
                                  'endDate': self._time_convert(endDate, "8601"), 'symbol': symbol, 'types': types}),
                             timeout=self.timeout)
 
-    def transaction_details(self, accountHash, transactionId):
+    def transaction_details(self, accountHash: str, transactionId: str | int) -> requests.Response:
         """
         Get specific transaction information for a specific account
         :param accountHash: account hash number
         :type accountHash: str
         :param transactionId: transaction id
-        :type transactionId: int
+        :type transactionId: str|int
         :return: transaction details of transaction id using accountHash
         :rtype: request.Response
         """
@@ -473,7 +474,7 @@ class Client:
                             params={'accountNumber': accountHash, 'transactionId': transactionId},
                             timeout=self.timeout)
 
-    def preferences(self):
+    def preferences(self) -> requests.Response:
         """
         Get user preference information for the logged in user.
         :return: User Preferences and Streaming Info
@@ -487,7 +488,7 @@ class Client:
     Market Data
     """
     
-    def quotes(self, symbols=None, fields=None, indicative=False):
+    def quotes(self, symbols=None, fields=None, indicative=False) -> requests.Response:
         """
         Get quotes for a list of tickers
         :param symbols: list of symbols strings (e.g. "AMD,INTC" or ["AMD", "INTC"])
@@ -505,7 +506,7 @@ class Client:
                                 {'symbols': self._format_list(symbols), 'fields': fields, 'indicative': indicative}),
                             timeout=self.timeout)
 
-    def quote(self, symbol_id, fields=None):
+    def quote(self, symbol_id: str, fields=None) -> requests.Response:
         """
         Get quote for a single symbol
         :param symbol_id: ticker symbol
@@ -520,9 +521,9 @@ class Client:
                             params=self._params_parser({'fields': fields}),
                             timeout=self.timeout)
 
-    def option_chains(self, symbol, contractType=None, strikeCount=None, includeUnderlyingQuote=None, strategy=None,
+    def option_chains(self, symbol: str, contractType=None, strikeCount=None, includeUnderlyingQuote=None, strategy=None,
                interval=None, strike=None, range=None, fromDate=None, toDate=None, volatility=None, underlyingPrice=None,
-               interestRate=None, daysToExpiration=None, expMonth=None, optionType=None, entitlement=None):
+               interestRate=None, daysToExpiration=None, expMonth=None, optionType=None, entitlement=None) -> requests.Response:
         """
         Get Option Chain including information on options contracts associated with each expiration for a ticker.
         :param symbol: ticker symbol
@@ -542,9 +543,9 @@ class Client:
         :param range: range ("ITM"|"NTM"|"OTM"...)
         :type range: str
         :param fromDate: from date
-        :type fromDate: datetime | str
+        :type fromDate: datetime.pyi | str
         :param toDate: to date
-        :type toDate: datetime | str
+        :type toDate: datetime.pyi | str
         :param volatility: volatility
         :type volatility: float
         :param underlyingPrice: underlying price
@@ -573,7 +574,7 @@ class Client:
                                  'expMonth': expMonth, 'optionType': optionType, 'entitlement': entitlement}),
                             timeout=self.timeout)
 
-    def option_expiration_chain(self, symbol):
+    def option_expiration_chain(self, symbol: str) -> requests.Response:
         """
         Get an option expiration chain for a ticker
         :param symbol: ticker symbol
@@ -586,8 +587,8 @@ class Client:
                             params=self._params_parser({'symbol': symbol}),
                             timeout=self.timeout)
 
-    def price_history(self, symbol, periodType=None, period=None, frequencyType=None, frequency=None, startDate=None,
-                      endDate=None, needExtendedHoursData=None, needPreviousClose=None):
+    def price_history(self, symbol: str, periodType=None, period=None, frequencyType=None, frequency=None, startDate=None,
+                      endDate=None, needExtendedHoursData=None, needPreviousClose=None) -> requests.Response:
         """
         Get price history for a ticker
         :param symbol: ticker symbol
@@ -601,9 +602,9 @@ class Client:
         :param frequency: frequency (1|5|10|15|30)
         :type frequency: int
         :param startDate: start date
-        :type startDate: datetime | str
+        :type startDate: datetime.pyi | str
         :param endDate: end date
-        :type endDate: datetime | str
+        :type endDate: datetime.pyi | str
         :param needExtendedHoursData: need extended hours data (True|False)
         :type needExtendedHoursData: boolean
         :param needPreviousClose: need previous close (True|False)
@@ -621,7 +622,7 @@ class Client:
                                                         'needPreviousClose': needPreviousClose}),
                             timeout=self.timeout)
 
-    def movers(self, symbol, sort=None, frequency=None):
+    def movers(self, symbol: str, sort=None, frequency=None) -> requests.Response:
         """
         Get movers in a specific index and direction
         :param symbol: symbol ("$DJI"|"$COMPX"|"$SPX"|"NYSE"|"NASDAQ"|"OTCBB"|"INDEX_ALL"|"EQUITY_ALL"|"OPTION_ALL"|"OPTION_PUT"|"OPTION_CALL")
@@ -634,17 +635,17 @@ class Client:
         :rtype: request.Response
         """
         return requests.get(f'{self._base_api_url}/marketdata/v1/movers/{symbol}',
-                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            headers={"accept": "application/json", 'Authorization': f'Bearer {self.access_token}'},
                             params=self._params_parser({'sort': sort, 'frequency': frequency}),
                             timeout=self.timeout)
 
-    def market_hours(self, symbols, date=None):
+    def market_hours(self, symbols, date=None) -> requests.Response:
         """
         Get Market Hours for dates in the future across different markets.
         :param symbols: list of market symbols ("equity", "option", "bond", "future", "forex")
         :type symbols: list
         :param date: date
-        :type date: datetime | str
+        :type date: datetime.pyi | str
         :return: market hours
         :rtype: request.Response
         """
@@ -655,13 +656,13 @@ class Client:
                                  'date': self._time_convert(date, 'YYYY-MM-DD')}),
                             timeout=self.timeout)
 
-    def market_hour(self, market_id, date=None):
+    def market_hour(self, market_id: str, date=None) -> requests.Response:
         """
         Get Market Hours for dates in the future for a single market.
         :param market_id: market id ("equity"|"option"|"bond"|"future"|"forex")
         :type market_id: str
         :param date: date
-        :type date: datetime | str
+        :type date: datetime.pyi | str
         :return: market hours
         :rtype: request.Response
         """
@@ -670,7 +671,7 @@ class Client:
                             params=self._params_parser({'date': self._time_convert(date, 'YYYY-MM-DD')}),
                             timeout=self.timeout)
 
-    def instruments(self, symbol, projection):
+    def instruments(self, symbol: str, projection) -> requests.Response:
         """
         Get instruments for a list of symbols
         :param symbol: symbol
@@ -685,11 +686,11 @@ class Client:
                             params={'symbol': symbol, 'projection': projection},
                             timeout=self.timeout)
 
-    def instrument_cusip(self, cusip_id):
+    def instrument_cusip(self, cusip_id: str | int) -> requests.Response:
         """
         Get instrument for a single cusip
         :param cusip_id: cusip id
-        :type cusip_id: str
+        :type cusip_id: str|int
         :return: instrument
         :rtype: request.Response
         """

{schwabdev-2.2.0 → schwabdev-2.2.2}/schwabdev/stream.py

@@ -52,13 +52,18 @@ class Stream:
             print("Could not get streamerInfo")
 
         # start the stream
+        start_time = datetime.now()
         while True:
             try:
+                start_time = datetime.now()
+                if self.verbose: print("Connecting to streaming server...")
                 async with websockets.connect(self._streamer_info.get('streamerSocketUrl'), ping_interval=None) as self._websocket:
-                    if self.verbose: print("Connected to streaming server.")
-
                     # send login payload
-                    login_payload = self.basic_request(service="ADMIN", command="LOGIN", parameters={"Authorization": self._client.access_token, "SchwabClientChannel": self._streamer_info.get("schwabClientChannel"), "SchwabClientFunctionId": self._streamer_info.get("schwabClientFunctionId")})
+                    login_payload = self.basic_request(service="ADMIN",
+                                                       command="LOGIN",
+                                                       parameters={"Authorization": self._client.access_token,
+                                                                   "SchwabClientChannel": self._streamer_info.get("schwabClientChannel"),
+                                                                   "SchwabClientFunctionId": self._streamer_info.get("schwabClientFunctionId")})
                     await self._websocket.send(json.dumps(login_payload))
                     receiver_func(await self._websocket.recv(), *args, **kwargs)
                     self.active = True
@@ -67,7 +72,10 @@ class Stream:
                     for service, subs in self.subscriptions.items():
                         reqs = []
                         for key, fields in subs.items():
-                            reqs.append(self.basic_request(service=service, command="ADD", parameters={"keys": key,  "fields": Stream._list_to_string(fields)}))
+                            reqs.append(self.basic_request(service=service,
+                                                           command="ADD",
+                                                           parameters={"keys": key,
+                                                                       "fields": Stream._list_to_string(fields)}))
                         if reqs:
                             await self._websocket.send(json.dumps({"requests": reqs}))
                             receiver_func(await self._websocket.recv(), *args, **kwargs)
@@ -84,6 +92,9 @@ class Stream:
                 elif e is websockets.exceptions.ConnectionClosedError or str(e) == "no close frame received or sent":  # catch no subscriptions kick
                     if self.verbose: print(f"Stream closed (likely no subscriptions): {e}")
                     break
+                elif (datetime.now() - start_time).seconds <= 90:
+                    if self.verbose: print("Stream has crashed within 90 seconds, likely no subscriptions or invalid login.")
+                    break
                 else: # stream has quit unexpectedly, try to reconnect
                     if self.verbose: print(f"{e}")
                     if self.verbose: print("Connection lost to server, reconnecting...")
@@ -100,7 +111,7 @@ class Stream:
 
             self._thread = threading.Thread(target=_start_async, daemon=False)
             self._thread.start()
-            sleep(1)  # if the thread does not start in time then the main program may close before the streamer starts
+            # if the thread does not start in time then the main program may close before the streamer starts
         else:
             print("Stream already active.")
 
@@ -126,6 +137,8 @@ class Stream:
             while True:
                 in_hours = (start <= datetime.now().time() <= end) and (0 <= datetime.now().weekday() <= 4)
                 if in_hours and not self.active:
+                    if len(self.subscriptions) == 0:
+                        if self.verbose: print("No subscriptions, starting stream anyways.")
                     self.start(receiver=receiver)
                 elif not in_hours and self.active:
                     if self.verbose: print("Stopping Stream.")
@@ -260,7 +273,7 @@ class Stream:
         if type(ls) is str: return ls
         elif type(ls) is list: return ",".join(map(str, ls))
 
-    def level_one_equities(self, keys, fields, command="ADD"):
+    def level_one_equities(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         Level one equities
         :param keys: list of keys to use (e.g. ["AMD", "INTC"])
@@ -274,7 +287,7 @@ class Stream:
         """
         return self.basic_request("LEVELONE_EQUITIES", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def level_one_options(self, keys, fields, command="ADD"):
+    def level_one_options(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         Level one options, key format: [Underlying Symbol (6 characters including spaces) | Expiration (6 characters) | Call/Put (1 character) | Strike Price (5+3=8 characters)]
         :param keys: list of keys to use (e.g. ["GOOG  240809C00095000", "AAPL  240517P00190000"])
@@ -288,7 +301,7 @@ class Stream:
         """
         return self.basic_request("LEVELONE_OPTIONS", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def level_one_futures(self, keys, fields, command="ADD"):
+    def level_one_futures(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         Level one futures, key format: '/' + 'root symbol' + 'month code' + 'year code'; month code is 1 character: (F: Jan, G: Feb, H: Mar, J: Apr, K: May, M: Jun, N: Jul, Q: Aug, U: Sep, V: Oct, X: Nov, Z: Dec), year code is 2 characters (i.e. 2024 = 24)
         :param keys: list of keys to use (e.g. ["/ESF24", "/GCG24"])
@@ -302,7 +315,7 @@ class Stream:
         """
         return self.basic_request("LEVELONE_FUTURES", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def level_one_futures_options(self, keys, fields, command="ADD"):
+    def level_one_futures_options(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         Level one futures options, key format: '.' + '/' + 'root symbol' + 'month code' + 'year code' + 'Call/Put code' + 'Strike Price'
         :param keys: list of keys to use (e.g. ["./OZCZ23C565"])
@@ -316,7 +329,7 @@ class Stream:
         """
         return self.basic_request("LEVELONE_FUTURES_OPTIONS", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def level_one_forex(self, keys, fields, command="ADD"):
+    def level_one_forex(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         Level one forex, key format: 'from currency' + '/' + 'to currency'
         :param keys: list of keys to use (e.g. ["EUR/USD", "JPY/USD"])
@@ -330,7 +343,7 @@ class Stream:
         """
         return self.basic_request("LEVELONE_FOREX", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def nyse_book(self, keys, fields, command="ADD"):
+    def nyse_book(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         NYSE book orders
         :param keys: list of keys to use (e.g. ["NIO", "F"])
@@ -344,7 +357,7 @@ class Stream:
         """
         return self.basic_request("NYSE_BOOK", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def nasdaq_book(self, keys, fields, command="ADD"):
+    def nasdaq_book(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         NASDAQ book orders
         :param keys: list of keys to use (e.g. ["AMD", "CRWD"])
@@ -358,7 +371,7 @@ class Stream:
         """
         return self.basic_request("NASDAQ_BOOK", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def options_book(self, keys, fields, command="ADD"):
+    def options_book(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         Options book orders
         :param keys: list of keys to use (e.g. ["GOOG  240809C00095000", "AAPL  240517P00190000"])
@@ -372,7 +385,7 @@ class Stream:
         """
         return self.basic_request("OPTIONS_BOOK", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def chart_equity(self, keys, fields, command="ADD"):
+    def chart_equity(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         Chart equity
         :param keys: list of keys to use (e.g. ["GOOG", "AAPL"])
@@ -386,7 +399,7 @@ class Stream:
         """
         return self.basic_request("CHART_EQUITY", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def chart_futures(self, keys, fields, command="ADD"):
+    def chart_futures(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         Chart futures, key format: '/' + 'root symbol' + 'month code' + 'year code'; month code is 1 character: (F: Jan, G: Feb, H: Mar, J: Apr, K: May, M: Jun, N: Jul, Q: Aug, U: Sep, V: Oct, X: Nov, Z: Dec), year code is 2 characters (i.e. 2024 = 24)
         :param keys: list of keys to use (e.g. ["/ESF24", "/GCG24"])
@@ -400,7 +413,7 @@ class Stream:
         """
         return self.basic_request("CHART_FUTURES", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def screener_equity(self, keys, fields, command="ADD"):
+    def screener_equity(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         Screener equity, key format: (PREFIX)_(SORTFIELD)_(FREQUENCY); Prefix: ($COMPX, $DJI, $SPX.X, INDEX_AL, NYSE, NASDAQ, OTCBB, EQUITY_ALL); Sortfield: (VOLUME, TRADES, PERCENT_CHANGE_UP, PERCENT_CHANGE_DOWN, AVERAGE_PERCENT_VOLUME), Frequency: (0 (all day), 1, 5, 10, 30 60)
         :param keys: list of keys to use (e.g. ["$DJI_PERCENT_CHANGE_UP_60", "NASDAQ_VOLUME_30"])
@@ -414,7 +427,7 @@ class Stream:
         """
         return self.basic_request("SCREENER_EQUITY", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def screener_option(self, keys, fields, command="ADD"):
+    def screener_options(self, keys: str | list, fields: str | list, command="ADD") -> dict:
         """
         Screener option key format: (PREFIX)_(SORTFIELD)_(FREQUENCY); Prefix: (OPTION_PUT, OPTION_CALL, OPTION_ALL); Sortfield: (VOLUME, TRADES, PERCENT_CHANGE_UP, PERCENT_CHANGE_DOWN, AVERAGE_PERCENT_VOLUME), Frequency: (0 (all day), 1, 5, 10, 30 60)
         :param keys: list of keys to use (e.g. ["OPTION_PUT_PERCENT_CHANGE_UP_60", "OPTION_CALL_TRADES_30"])
@@ -428,7 +441,7 @@ class Stream:
         """
         return self.basic_request("SCREENER_OPTION", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
 
-    def account_activity(self, keys="Account Activity", fields="0,1,2,3", command="SUBS"):
+    def account_activity(self, keys="Account Activity", fields="0,1,2,3", command="SUBS") -> dict:
         """
         Account activity
         :param keys: list of keys to use (e.g. ["Account Activity"])

{schwabdev-2.2.0 → schwabdev-2.2.2}/schwabdev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schwabdev
-Version: 2.2.0
+Version: 2.2.2
 Summary: An easy and lightweight wrapper for using the Charles Schwab API.
 Author: Tyler Bowers
 Author-email: tylerebowers@gmail.com
@@ -19,6 +19,8 @@ Classifier: Natural Language :: English
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Requires-Dist: requests
+Requires-Dist: websockets
 
 # Schwab-API-Python
 ![PyPI - Version](https://img.shields.io/pypi/v/schwabdev) ![Discord](https://img.shields.io/discord/1076596998150561873?logo=discord) ![PyPI - Downloads](https://img.shields.io/pypi/dm/schwabdev) [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/donate/?business=8VDFKHMBFSC2Q&no_recurring=0&currency_code=USD) ![YouTube Video Views](https://img.shields.io/youtube/views/kHbom0KIJwc?style=flat&logo=youtube)  
@@ -54,6 +56,7 @@ print(client.account_linked().json()) #make api calls
  - Functions for all api functions (examples in `examples/api_demo.py`)
  - Stream real-time data with a customizable response handler (examples in `examples/stream_demo.py`)
  ### TBD 
+ - Paper trading client
  - Automatic refresh token updates. (Waiting for Schwab implementation)
 ### Notes
 The schwabdev folder contains code for main operations:     

{schwabdev-2.2.0 → schwabdev-2.2.2}/schwabdev.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ README.md
 setup.py
 schwabdev/__init__.py
 schwabdev/api.py
-schwabdev/color_print.py
 schwabdev/stream.py
 schwabdev.egg-info/PKG-INFO
 schwabdev.egg-info/SOURCES.txt

{schwabdev-2.2.0 → schwabdev-2.2.2}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-VERSION = '2.2.0'
+VERSION = '2.2.2'
 DESCRIPTION = 'An easy and lightweight wrapper for using the Charles Schwab API.'
 with open('README.md', 'r') as f:
     LONG_DESCRIPTION = f.read()

schwabdev-2.2.0/schwabdev/color_print.py

@@ -1,19 +0,0 @@
-"""
-This file is used to print colored text
-Github: https://github.com/tylerebowers/Schwab-API-Python
-"""
-
-
-def info(string, end="\n"): print(f"\033[92m{'[INFO]: '}\033[00m{string}", end=end)
-
-
-def warning(string, end="\n"): print(f"\033[93m{'[WARN]: '}\033[00m{string}", end=end)
-
-
-def error(string, end="\n"): print(f"\033[91m{'[ERROR]: '}\033[00m{string}", end=end)
-
-
-def user(string, end="\n"): print(f"\033[94m{'[USER]: '}\033[00m{string}", end=end)
-
-
-def user_input(string): return input(f"\033[94m{'[INPUT]: '}\033[00m{string}")