PyPI - schwabdev - Versions diffs - 2.2.2__tar.gz → 2.2.4__tar.gz - Mend

schwabdev 2.2.2tar.gz → 2.2.4tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

{schwabdev-2.2.2 → schwabdev-2.2.4}/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schwabdev
-Version: 2.2.2
+Version: 2.2.4
 Summary: An easy and lightweight wrapper for using the Charles Schwab API.
 Author: Tyler Bowers
 Author-email: tylerebowers@gmail.com
@@ -28,20 +28,22 @@ This is an unofficial python program to access the Schwab api.
 [Discord](https://discord.gg/m7SSjr9rs9), [PyPI](https://pypi.org/project/schwabdev/), [Youtube](https://youtube.com/playlist?list=PLs4JLWxBQIxpbvCj__DjAc0RRTlBz-TR8), [Github](https://github.com/tylerebowers/Schwab-API-Python).
 ## Installation
-`pip install schwabdev requests websockets`
+`pip install schwabdev`
 *You may need to use `pip3` instead of `pip`*
 ## Quick setup
 1. Setup your Schwab developer account [here](https://beta-developer.schwab.com/).
    - Create a new Schwab individual developer app with callback url "https://127.0.0.1" (case sensitive)
+   - Add both API products to your app: "Accounts and Trading Production" and "Market Data Production".
    - Wait until the status is "Ready for use", note that "Approved - Pending" will not work.
    - Enable TOS (Thinkorswim) for your Schwab account, it is needed for orders and other api calls.
 2. Install packages
-   - Install schwabdev and requirements `pip install schwabdev requests websockets`
+   - Install schwabdev and requirements `pip install schwabdev`
    - *You may need to use `pip3` instead of `pip`*
 3. Examples on how to use the client are in the `examples/` folder (add your keys in the .env file)
-   - The first time you run you will have to sign in to your Schwab account using the generated link in the terminal. After signing in, agree to the terms, and select account(s). Then you will have to copy the link in the address bar and paste it into the terminal.
-   - Questions? - join the [Discord group](https://discord.gg/m7SSjr9rs9).
+   - The first time you run you will have to sign in to your Schwab account using the generated link in the terminal.
+   - After signing in, agree to the terms, and select account(s). Then you will have to copy the link in the address bar and paste it into the terminal.
+   - Questions? - join the [Discord group](https://discord.gg/m7SSjr9rs9) or consult the `/docs` folder.
 ```py
 import schwabdev #import the package

{schwabdev-2.2.2 → schwabdev-2.2.4}/README.md RENAMED Viewed

@@ -4,20 +4,22 @@ This is an unofficial python program to access the Schwab api.
 [Discord](https://discord.gg/m7SSjr9rs9), [PyPI](https://pypi.org/project/schwabdev/), [Youtube](https://youtube.com/playlist?list=PLs4JLWxBQIxpbvCj__DjAc0RRTlBz-TR8), [Github](https://github.com/tylerebowers/Schwab-API-Python).
 ## Installation
-`pip install schwabdev requests websockets`
+`pip install schwabdev`
 *You may need to use `pip3` instead of `pip`*
 ## Quick setup
 1. Setup your Schwab developer account [here](https://beta-developer.schwab.com/).
    - Create a new Schwab individual developer app with callback url "https://127.0.0.1" (case sensitive)
+   - Add both API products to your app: "Accounts and Trading Production" and "Market Data Production".
    - Wait until the status is "Ready for use", note that "Approved - Pending" will not work.
    - Enable TOS (Thinkorswim) for your Schwab account, it is needed for orders and other api calls.
 2. Install packages
-   - Install schwabdev and requirements `pip install schwabdev requests websockets`
+   - Install schwabdev and requirements `pip install schwabdev`
    - *You may need to use `pip3` instead of `pip`*
 3. Examples on how to use the client are in the `examples/` folder (add your keys in the .env file)
-   - The first time you run you will have to sign in to your Schwab account using the generated link in the terminal. After signing in, agree to the terms, and select account(s). Then you will have to copy the link in the address bar and paste it into the terminal.
-   - Questions? - join the [Discord group](https://discord.gg/m7SSjr9rs9).
+   - The first time you run you will have to sign in to your Schwab account using the generated link in the terminal.
+   - After signing in, agree to the terms, and select account(s). Then you will have to copy the link in the address bar and paste it into the terminal.
+   - Questions? - join the [Discord group](https://discord.gg/m7SSjr9rs9) or consult the `/docs` folder.
 ```py
 import schwabdev #import the package

schwabdev-2.2.4/pyproject.toml ADDED Viewed

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"

{schwabdev-2.2.2 → schwabdev-2.2.4}/schwabdev/api.py RENAMED Viewed

@@ -1,3 +1,9 @@
+"""
+This file contains functions access the Schwab api
+Coded by Tyler Bowers
+Github: https://github.com/tylerebowers/Schwab-API-Python
+"""
 import json
 import time
 import base64
@@ -6,6 +12,7 @@ import requests
 import threading
 import webbrowser
 import urllib.parse
 from .stream import Stream
 class Client:
@@ -48,21 +55,22 @@ class Client:
         elif timeout <= 0:
             raise Exception("Timeout must be greater than 0 and is recomended to be 5 seconds or more.")
-        self._app_key = app_key             # app key credential
-        self._app_secret = app_secret       # app secret credential
-        self._callback_url = callback_url   # callback url to use
-        self.access_token = None            # access token from auth
-        self.refresh_token = None           # refresh token from auth
-        self.id_token = None                # id token from auth
-        self._access_token_issued = None    # datetime of access token issue
-        self._refresh_token_issued = None   # datetime of refresh token issue
-        self._access_token_timeout = 1800   # in seconds (from schwab)
-        self._refresh_token_timeout = 7     # in days (from schwab)
-        self._tokens_file = tokens_file     # path to tokens file
-        self.timeout = timeout              # timeout to use in requests
-        self.verbose = verbose              # verbose mode
-        self.stream = Stream(self)          # init the streaming object
-        self.awaiting_input = False         # whether we are awaiting user input
+        self.version = "2.2.4"
+        self._app_key = app_key                   # app key credential
+        self._app_secret = app_secret             # app secret credential
+        self._callback_url = callback_url         # callback url to use
+        self.access_token = None                  # access token from auth
+        self.refresh_token = None                 # refresh token from auth
+        self.id_token = None                      # id token from auth
+        self._access_token_issued = None          # datetime of access token issue
+        self._refresh_token_issued = None         # datetime of refresh token issue
+        self._access_token_timeout = 1800         # in seconds (from schwab)
+        self._refresh_token_timeout = 7*24*60*60  # in seconds (from schwab)
+        self._tokens_file = tokens_file           # path to tokens file
+        self.timeout = timeout                    # timeout to use in requests
+        self.verbose = verbose                    # verbose mode
+        self.stream = Stream(self)                # init the streaming object
+        self.awaiting_input = False               # whether we are awaiting user input
         # Try to load tokens from the tokens file
         at_issued, rt_issued, token_dictionary = self._read_tokens_file()
@@ -74,14 +82,16 @@ 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.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)")
+                at_delta = self._access_token_timeout - (datetime.datetime.now(datetime.timezone.utc) - self._access_token_issued).total_seconds()
+                print(f"[Schwabdev] Access token expires in {"-" if at_delta < 0 else ""}{int(abs(at_delta) / 3600)}:{int((abs(at_delta) % 3600) / 60)}:{int((abs(at_delta) % 60))}")
+                rt_delta = self._refresh_token_timeout - (datetime.datetime.now(datetime.timezone.utc) - self._refresh_token_issued).total_seconds()
+                print(f"[Schwabdev] Refresh token expires in {"-" if rt_delta < 0 else ""}{int(abs(rt_delta) / 3600)}:{int((abs(rt_delta) % 3600) / 60)}:{int((abs(rt_delta) % 60))}")
             # check if tokens need to be updated and update if needed
             self.update_tokens()
         else:
             # The tokens file doesn't exist, so create it.
             if self.verbose:
-                print(f"Token file does not exist or invalid formatting, creating \"{str(tokens_file)}\"")
+                print(f"[Schwabdev] Token file does not exist or invalid formatting, creating \"{str(tokens_file)}\"")
             open(self._tokens_file, 'w').close()
             # Tokens must be updated.
             self._update_refresh_token()
@@ -91,13 +101,13 @@ class Client:
             def checker():
                 while True:
                     self.update_tokens()
-                    time.sleep(60)
+                    time.sleep(30)
             threading.Thread(target=checker, daemon=True).start()
-        elif not self.verbose:
-            print("Warning: Tokens will not be updated automatically.")
+        elif self.verbose:
+            print("[Schwabdev] Warning: Tokens will not be updated automatically.")
         if self.verbose:
-            print("Schwabdev Client Initialization Complete")
+            print("[Schwabdev] Client Initialization Complete")
     def update_tokens(self, force=False):
         """
@@ -105,17 +115,21 @@ class Client:
         :param force: force update of refresh token (also updates access token)
         :type force: bool
         """
-        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!")
+        #refresh token notification.
+        rt_delta = self._refresh_token_timeout - (datetime.datetime.now(datetime.timezone.utc) - self._refresh_token_issued).total_seconds()
+        if rt_delta < 43200: # Start to ware the user if the refresh token will expire in less than 43200 = 12 hours
+            print(f"[Schwabdev] The refresh token will expire soon! ({"-" if rt_delta < 0 else ""}{int(abs(rt_delta) / 3600)}:{int((abs(rt_delta) % 3600) / 60)}:{int((abs(rt_delta) % 60))} remaining)")
+        if (rt_delta < 3600) or force:  # check if we need to update refresh (and access) token
+            print("[Schwabdev] The refresh token has expired!")
             self._update_refresh_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.")
+        elif (self._access_token_timeout - (datetime.datetime.now(datetime.timezone.utc) - self._access_token_issued).total_seconds()) < 61:  # check if we need to update access token
+            if self.verbose: print("[Schwabdev] The access token has expired, updating automatically.")
             self._update_access_token()
     def update_tokens_auto(self):
         import warnings
-        warnings.warn("update_tokens_auto() is deprecated and is now started when the client is created (if update_tokens_auto=True (default)).", DeprecationWarning, stacklevel=2)
+        warnings.warn("update_tokens_auto() is deprecated and is now started by default when the client is created (if update_tokens_auto=True (default)).", DeprecationWarning, stacklevel=2)
     def _update_access_token(self):
         """
@@ -136,11 +150,11 @@ class Client:
                 self.id_token = new_td.get("id_token")
                 self._write_tokens_file(self._access_token_issued, refresh_token_issued, new_td)
                 if self.verbose: # show user that we have updated the access token
-                    print(f"Access token updated: {self._access_token_issued}")
+                    print(f"[Schwabdev] Access token updated: {self._access_token_issued}")
                 break
             else:
                 print(response.text)
-                print(f"Could not get new access token ({i+1} of 3).")
+                print(f"[Schwabdev] Could not get new access token ({i+1} of 3).")
                 time.sleep(10)
     def _update_refresh_token(self):
@@ -149,9 +163,9 @@ class Client:
         """
         self.awaiting_input = True # set flag since we are waiting for user input
         # get authorization code (requires user to authorize)
-        #print("Please authorize this program to access your schwab account.")
+        #print("[Schwabdev] Please authorize this program to access your schwab account.")
         auth_url = f'https://api.schwabapi.com/v1/oauth/authorize?client_id={self._app_key}&redirect_uri={self._callback_url}'
-        print(f"Open to authenticate: {auth_url}")
+        print(f"[Schwabdev] Open to authenticate: {auth_url}")
         webbrowser.open(auth_url)
         response_url = input("After authorizing, paste the address bar url here: ")
         code = f"{response_url[response_url.index('code=') + 5:response_url.index('%40')]}@"  # session = responseURL[responseURL.index("session=")+8:]
@@ -166,14 +180,14 @@ class Client:
             self.awaiting_input = False  # reset flag since tokens have been updated
             self.id_token = new_td.get("id_token")
             self._write_tokens_file(self._access_token_issued, self._refresh_token_issued, new_td)
-            if self.verbose: print("Refresh and Access tokens updated")
+            if self.verbose: print("[Schwabdev] 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 "
+            print("[Schwabdev] 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)")
-    def _post_oauth_token(self, grant_type, code):
+    def _post_oauth_token(self, grant_type: str, code: str):
         """
         Makes API calls for auth code and refresh tokens
         :param grant_type: 'authorization_code' or 'refresh_token'
@@ -195,7 +209,7 @@ class Client:
             raise Exception("Invalid grant type; options are 'authorization_code' or 'refresh_token'")
         return requests.post('https://api.schwabapi.com/v1/oauth/token', headers=headers, data=data)
-    def _write_tokens_file(self, at_issued, rt_issued, token_dictionary):
+    def _write_tokens_file(self, at_issued: datetime, rt_issued: datetime, token_dictionary: dict):
         """
         Writes token file
         :param at_issued: access token issued
@@ -229,7 +243,7 @@ class Client:
             print(e)
             return None, None, None
-    def _params_parser(self, params):
+    def _params_parser(self, params: dict):
         """
         Removes None (null) values
         :param params: params to remove None values from
@@ -241,11 +255,11 @@ class Client:
             if params[key] is None: del params[key]
         return params
-    def _time_convert(self, dt=None, form="8601"):
+    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.pyi object to convert
-        :type dt: datetime.pyi
+        :type dt: datetime.pyi | str | None
         :param form: what to convert input to
         :type form: str
         :return: converted time or passthrough
@@ -295,11 +309,11 @@ class Client:
                             headers={'Authorization': f'Bearer {self.access_token}'},
                             timeout=self.timeout)
-    def account_details_all(self, fields=None) -> requests.Response:
+    def account_details_all(self, fields: str = 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")
-        :type fields: str
+        :type fields: str | None
         :return: details for all linked accounts
         :rtype: request.Response
         """
@@ -308,13 +322,13 @@ class Client:
                             params=self._params_parser({'fields': fields}),
                             timeout=self.timeout)
-    def account_details(self, accountHash: str, fields=None) -> requests.Response:
+    def account_details(self, accountHash: str, fields: str = 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()
         :type accountHash: str
         :param fields: fields to return
-        :type fields: str
+        :type fields: str | None
         :return: details for one linked account
         :rtype: request.Response
         """
@@ -323,7 +337,7 @@ class Client:
                             params=self._params_parser({'fields': fields}),
                             timeout=self.timeout)
-    def account_orders(self, accountHash: str, fromEnteredTime: 'datetime | str', toEnteredTime: 'datetime | str', maxResults=None, status=None) -> requests.Response:
+    def account_orders(self, accountHash: str, fromEnteredTime: datetime.datetime | str, toEnteredTime: datetime.datetime | str, maxResults: int = None, status: str = 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()
@@ -333,9 +347,9 @@ class Client:
         :param toEnteredTime: to entered time
         :type toEnteredTime: datetime.pyi | str
         :param maxResults: maximum number of results
-        :type maxResults: int
+        :type maxResults: int| None
         :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")
-        :type status: str
+        :type status: str| None
         :return: orders for one linked account hash
         :rtype: request.Response
         """
@@ -362,7 +376,7 @@ class Client:
                              json=order,
                              timeout=self.timeout)
-    def order_details(self, accountHash:str, orderId: int | str) -> requests.Response:
+    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()
@@ -408,7 +422,7 @@ class Client:
                             json=order,
                             timeout=self.timeout)
-    def account_orders_all(self, fromEnteredTime: 'datetime | str', toEnteredTime: 'datetime | str', maxResults=None, status=None) -> requests.Response:
+    def account_orders_all(self, fromEnteredTime: datetime.datetime | str, toEnteredTime: datetime.datetime | str, maxResults: int = None, status: str = None) -> requests.Response:
         """
         Get all orders for all accounts
         :param fromEnteredTime: start date
@@ -416,9 +430,9 @@ class Client:
         :param toEnteredTime: end date
         :type toEnteredTime: datetime.pyi | str
         :param maxResults: maximum number of results (set to None for default 3000)
-        :type maxResults: int
+        :type maxResults: int | None
         :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")
-        :type status: str
+        :type status: str | None
         :return: all orders
         :rtype: request.Response
         """
@@ -437,7 +451,7 @@ class Client:
                                       "Content-Type": "application.json"}, data=orderObject)
     """
-    def transactions(self, accountHash: str, startDate: 'datetime | str', endDate: 'datetime | str', types: str, symbol=None) -> requests.Response:
+    def transactions(self, accountHash: str, startDate: datetime.datetime | str, endDate: datetime.datetime | str, types: str, symbol: str = 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
@@ -488,15 +502,15 @@ class Client:
     Market Data
     """
-    def quotes(self, symbols=None, fields=None, indicative=False) -> requests.Response:
+    def quotes(self, symbols : list[str] | str, fields: str = None, indicative: bool = False) -> requests.Response:
         """
         Get quotes for a list of tickers
         :param symbols: list of symbols strings (e.g. "AMD,INTC" or ["AMD", "INTC"])
         :type symbols: [str] | str
-        :param fields: list of fields to get ("all", "quote", "fundamental")
-        :type fields: list
+        :param fields: string of fields to get ("all", "quote", "fundamental")
+        :type fields: str | None
         :param indicative: whether to get indicative quotes (True/False)
-        :type indicative: boolean
+        :type indicative: boolean | None
         :return: list of quotes
         :rtype: request.Response
         """
@@ -506,24 +520,24 @@ class Client:
                                 {'symbols': self._format_list(symbols), 'fields': fields, 'indicative': indicative}),
                             timeout=self.timeout)
-    def quote(self, symbol_id: str, fields=None) -> requests.Response:
+    def quote(self, symbol_id: str, fields: str = None) -> requests.Response:
         """
         Get quote for a single symbol
         :param symbol_id: ticker symbol
         :type symbol_id: str (e.g. "AAPL", "/ES", "USD/EUR")
-        :param fields: list of fields to get ("all", "quote", "fundamental")
-        :type fields: list
+        :param fields: string of fields to get ("all", "quote", "fundamental")
+        :type fields: str | None
         :return: quote for a single symbol
         :rtype: request.Response
         """
-        return requests.get(f'{self._base_api_url}/marketdata/v1/{urllib.parse.quote(symbol_id)}/quotes',
+        return requests.get(f'{self._base_api_url}/marketdata/v1/{urllib.parse.quote_plus(symbol_id)}/quotes',
                             headers={'Authorization': f'Bearer {self.access_token}'},
                             params=self._params_parser({'fields': fields}),
                             timeout=self.timeout)
-    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) -> requests.Response:
+    def option_chains(self, symbol: str, contractType: str = None, strikeCount: any = None, includeUnderlyingQuote: bool = None, strategy: str = None,
+               interval: any = None, strike: any = None, range: str = None, fromDate: datetime.datetime | str = None, toDate: datetime.datetime | str = None, volatility: any = None, underlyingPrice: any = None,
+               interestRate: any = None, daysToExpiration: any = None, expMonth: str = None, optionType: str = None, entitlement: str = None) -> requests.Response:
         """
         Get Option Chain including information on options contracts associated with each expiration for a ticker.
         :param symbol: ticker symbol
@@ -587,8 +601,8 @@ class Client:
                             params=self._params_parser({'symbol': symbol}),
                             timeout=self.timeout)
-    def price_history(self, symbol: str, periodType=None, period=None, frequencyType=None, frequency=None, startDate=None,
-                      endDate=None, needExtendedHoursData=None, needPreviousClose=None) -> requests.Response:
+    def price_history(self, symbol: str, periodType: str = None, period: any = None, frequencyType: str = None, frequency: any = None, startDate: datetime.datetime | str = None,
+                      endDate: any = None, needExtendedHoursData: bool = None, needPreviousClose: bool = None) -> requests.Response:
         """
         Get price history for a ticker
         :param symbol: ticker symbol
@@ -622,7 +636,7 @@ class Client:
                                                         'needPreviousClose': needPreviousClose}),
                             timeout=self.timeout)
-    def movers(self, symbol: str, sort=None, frequency=None) -> requests.Response:
+    def movers(self, symbol: str, sort: str = None, frequency: any = 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")
@@ -639,7 +653,7 @@ class Client:
                             params=self._params_parser({'sort': sort, 'frequency': frequency}),
                             timeout=self.timeout)
-    def market_hours(self, symbols, date=None) -> requests.Response:
+    def market_hours(self, symbols: list[str], date: datetime.datetime | str = 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")
@@ -656,7 +670,7 @@ class Client:
                                  'date': self._time_convert(date, 'YYYY-MM-DD')}),
                             timeout=self.timeout)
-    def market_hour(self, market_id: str, date=None) -> requests.Response:
+    def market_hour(self, market_id: str, date: datetime.datetime | str = 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")
@@ -671,7 +685,7 @@ class Client:
                             params=self._params_parser({'date': self._time_convert(date, 'YYYY-MM-DD')}),
                             timeout=self.timeout)
-    def instruments(self, symbol: str, projection) -> requests.Response:
+    def instruments(self, symbol: str, projection: str) -> requests.Response:
         """
         Get instruments for a list of symbols
         :param symbol: symbol

{schwabdev-2.2.2 → schwabdev-2.2.4}/schwabdev/stream.py RENAMED Viewed

@@ -7,11 +7,11 @@ Github: https://github.com/tylerebowers/Schwab-API-Python
 import json
 import atexit
 import asyncio
+import datetime
 import threading
 import websockets
 from time import sleep
 import websockets.exceptions
-from datetime import datetime, time
 class Stream:
@@ -28,7 +28,6 @@ class Stream:
         self.active = False             # whether the stream is active
         self._thread = None             # the thread that runs the stream
         self._client = client           # so we can get streamer info
-        self.verbose = client.verbose   # inherit the client's verbose setting
         self.subscriptions = {}         # a dictionary of subscriptions
         # register atexit to stop the stream (if active)
@@ -38,7 +37,7 @@ class Stream:
         atexit.register(stop_atexit)
-    async def _start_streamer(self, receiver_func=print, *args, **kwargs):
+    async def _start_streamer(self, receiver_func=print, **kwargs):
         """
         Start the streamer
         :param receiver_func: function to call when data is received
@@ -49,15 +48,17 @@ class Stream:
         if response.ok:
             self._streamer_info = response.json().get('streamerInfo', None)[0]
         else:
-            print("Could not get streamerInfo")
+            print("[Schwabdev] Could not get streamerInfo")
+            return
         # start the stream
-        start_time = datetime.now()
+        start_time = datetime.datetime.now(datetime.timezone.utc)
         while True:
             try:
-                start_time = datetime.now()
-                if self.verbose: print("Connecting to streaming server...")
+                start_time = datetime.datetime.now(datetime.timezone.utc)
+                if self._client.verbose: print("[Schwabdev] Connecting to streaming server...")
                 async with websockets.connect(self._streamer_info.get('streamerSocketUrl'), ping_interval=None) as self._websocket:
+                    if self._client.verbose: print("[Schwabdev] Connected to streaming server.")
                     # send login payload
                     login_payload = self.basic_request(service="ADMIN",
                                                        command="LOGIN",
@@ -65,7 +66,7 @@ class Stream:
                                                                    "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)
+                    receiver_func(await self._websocket.recv(), **kwargs)
                     self.active = True
                     # send subscriptions
@@ -78,44 +79,45 @@ class Stream:
                                                                        "fields": Stream._list_to_string(fields)}))
                         if reqs:
                             await self._websocket.send(json.dumps({"requests": reqs}))
-                            receiver_func(await self._websocket.recv(), *args, **kwargs)
+                            receiver_func(await self._websocket.recv(), **kwargs)
                     # main listener loop
                     while True:
-                        receiver_func(await self._websocket.recv(), *args, **kwargs)
+                        receiver_func(await self._websocket.recv(), **kwargs)
             except Exception as e:
                 self.active = False
                 if e is websockets.exceptions.ConnectionClosedOK or str(e) == "received 1000 (OK); then sent 1000 (OK)":  # catch logout request
-                    if self.verbose: print("Stream has closed.")
+                    if self._client.verbose: print("[Schwabdev] Stream connection closed.")
                     break
                 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}")
+                    print(f"[Schwabdev] Stream connection 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.")
+                elif (datetime.datetime.now(datetime.timezone.utc) - start_time).seconds <= 90:
+                    print(f"[Schwabdev] Stream has crashed within 90 seconds ({e}), likely no subscriptions, invalid login, or lost connection (not restarting).")
                     break
                 else: # stream has quit unexpectedly, try to reconnect
-                    if self.verbose: print(f"{e}")
-                    if self.verbose: print("Connection lost to server, reconnecting...")
+                    print(f"[Schwabdev] Stream connection lost to server ({e}), reconnecting...")
-    def start(self, receiver=print, *args, **kwargs):
+    def start(self, receiver=print, daemon: bool = True, **kwargs):
         """
         Start the stream
         :param receiver: function to call when data is received
         :type receiver: function
+        :param daemon: whether to run the thread in the background (as a daemon)
+        :type daemon: bool
         """
         if not self.active:
             def _start_async():
-                asyncio.run(self._start_streamer(receiver, *args, **kwargs))
+                asyncio.run(self._start_streamer(receiver, **kwargs))
-            self._thread = threading.Thread(target=_start_async, daemon=False)
+            self._thread = threading.Thread(target=_start_async, daemon=daemon)
             self._thread.start()
             # if the thread does not start in time then the main program may close before the streamer starts
         else:
-            print("Stream already active.")
+            if self._client.verbose: print("[Schwabdev] Stream already active.")
-    def start_automatic(self, receiver=print, after_hours=False, pre_hours=False):
+    def start_auto(self, receiver=print, after_hours=False, pre_hours=False, daemon: bool = True, **kwargs):
         """
         Start the stream automatically at market open and close, will NOT erase subscriptions
         :param receiver: function to call when data is received
@@ -125,32 +127,32 @@ class Stream:
         :param pre_hours: include pre hours trading
         :type pre_hours: bool
         """
-        start = time(9, 29, 0)  # market opens at 9:30
-        end = time(16, 0, 0)  # market closes at 4:00
+        start = datetime.time(13, 29, 0, tzinfo=datetime.timezone.utc)  # market opens at 9:30 ET
+        end = datetime.time(20, 0, 0, tzinfo=datetime.timezone.utc)  # market closes at 4:00 ET
         if pre_hours:
-            start = time(7, 59, 0)
+            start = datetime.time(10, 59, 0, tzinfo=datetime.timezone.utc)
         if after_hours:
-            end = time(20, 0, 0)
+            end = datetime.time.max.replace(tzinfo=datetime.timezone.utc) # 23:59:59:999999
         def checker():
             while True:
-                in_hours = (start <= datetime.now().time() <= end) and (0 <= datetime.now().weekday() <= 4)
+                now = datetime.datetime.now(datetime.timezone.utc)
+                in_hours = (start <= now.time().replace(tzinfo=datetime.timezone.utc) <= end) and (0 <= 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)
+                        if self._client.verbose: print("[Schwabdev] No subscriptions, starting stream anyways.")
+                    self.start(receiver=receiver, daemon=daemon, **kwargs)
                 elif not in_hours and self.active:
-                    if self.verbose: print("Stopping Stream.")
+                    if self._client.verbose: print("[Schwabdev] Stopping Stream.")
                     self.stop(clear_subscriptions=False)
-                sleep(60)
+                sleep(30)
-        threading.Thread(target=checker).start()
+        threading.Thread(target=checker, daemon=daemon).start()
-        if not start <= datetime.now().time() <= end:
-            print("Stream was started outside of active hours and will launch when in hours.")
+        if not start <= datetime.datetime.now(datetime.timezone.utc).time().replace(tzinfo=datetime.timezone.utc) <= end:
+            print("[Schwabdev] Stream was started outside of active hours and will launch when in hours.")
-    def _record_request(self, request):
+    def _record_request(self, request: dict):
         """
         Record the request into self.subscriptions (for the event of crashes)
         :param request: request
@@ -188,7 +190,7 @@ class Stream:
-    def send(self, requests):
+    def send(self, requests: list | dict):
         """
         Send a request to the stream
         :param requests: list of requests or a single request
@@ -211,10 +213,33 @@ class Stream:
             to_send = json.dumps({"requests": requests})
             asyncio.run(_send(to_send))
         else:
-            if self.verbose: print("Stream is not active, request queued.")
+            if self._client.verbose: print("[Schwabdev] Stream is not active, request queued.")
-    def stop(self, clear_subscriptions=True):
+    async def send_async(self, requests: list | dict):
+        """
+        Send an async (must be awaited) request to the stream (functionally equivalent to send)
+        :param requests: list of requests or a single request
+        :type requests: list | dict
+        """
+        # make sure requests is a list
+        if type(requests) is not list:
+            requests = [requests]
+        # add requests to list of subscriptions
+        for request in requests:
+            self._record_request(request)
+        # send the request if the stream is active, queue otherwise
+        if self.active:
+            to_send = json.dumps({"requests": requests})
+            await self._websocket.send(to_send)
+        else:
+            if self._client.verbose: print("[Schwabdev] Stream is not active, request queued.")
+    def stop(self, clear_subscriptions: bool = True):
         """
         Stop the stream
         :param clear_subscriptions: clear records
@@ -226,7 +251,7 @@ class Stream:
         self.send(self.basic_request(service="ADMIN", command="LOGOUT"))
         self.active = False
-    def basic_request(self, service, command, parameters=None):
+    def basic_request(self, service: str, command: str, parameters: dict = None):
         """
         Create a basic request (all requests follow this format)
         :param service: service to use
@@ -242,27 +267,26 @@ class Stream:
             response = self._client.preferences()
             if response.ok:
                 self._streamer_info = response.json().get('streamerInfo', None)[0]
+            else:
+                print("[Schwabdev] Could not use/get streamerInfo")
+                return {}
         # remove None parameters
         if parameters is not None:
             for key in parameters.keys():
                 if parameters[key] is None: del parameters[key]
-        if self._streamer_info is not None:
-            request = {"service": service.upper(),
-                       "command": command.upper(),
-                       "requestid": self._request_id,
-                       "SchwabClientCustomerId": self._streamer_info.get("schwabClientCustomerId"),
-                       "SchwabClientCorrelId": self._streamer_info.get("schwabClientCorrelId")}
-            if parameters is not None and len(parameters) > 0: request["parameters"] = parameters
-            self._request_id += 1
-            return request
-        else:
-            print("basic_request(): Could not use/get streamerInfo")
-            return None
+        self._request_id += 1
+        request = {"service": service.upper(),
+                   "command": command.upper(),
+                   "requestid": self._request_id,
+                   "SchwabClientCustomerId": self._streamer_info.get("schwabClientCustomerId"),
+                   "SchwabClientCorrelId": self._streamer_info.get("schwabClientCorrelId")}
+        if parameters is not None and len(parameters) > 0: request["parameters"] = parameters
+        return request
     @staticmethod
-    def _list_to_string(ls):
+    def _list_to_string(ls: list | str):
         """
         Convert a list to a string (e.g. [1, "B", 3] -> "1,B,3"), or passthrough if already a string
         :param ls: list to convert
@@ -273,7 +297,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: str | list, fields: str | list, command="ADD") -> dict:
+    def level_one_equities(self, keys: str | list, fields: str | list, command: str = "ADD") -> dict:
         """
         Level one equities
         :param keys: list of keys to use (e.g. ["AMD", "INTC"])
@@ -287,7 +311,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: str | list, fields: str | list, command="ADD") -> dict:
+    def level_one_options(self, keys: str | list, fields: str | list, command: str = "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"])
@@ -301,7 +325,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: str | list, fields: str | list, command="ADD") -> dict:
+    def level_one_futures(self, keys: str | list, fields: str | list, command: str = "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"])
@@ -315,7 +339,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: str | list, fields: str | list, command="ADD") -> dict:
+    def level_one_futures_options(self, keys: str | list, fields: str | list, command: str = "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"])
@@ -329,7 +353,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: str | list, fields: str | list, command="ADD") -> dict:
+    def level_one_forex(self, keys: str | list, fields: str | list, command: str = "ADD") -> dict:
         """
         Level one forex, key format: 'from currency' + '/' + 'to currency'
         :param keys: list of keys to use (e.g. ["EUR/USD", "JPY/USD"])
@@ -343,7 +367,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: str | list, fields: str | list, command="ADD") -> dict:
+    def nyse_book(self, keys: str | list, fields: str | list, command: str = "ADD") -> dict:
         """
         NYSE book orders
         :param keys: list of keys to use (e.g. ["NIO", "F"])
@@ -357,7 +381,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: str | list, fields: str | list, command="ADD") -> dict:
+    def nasdaq_book(self, keys: str | list, fields: str | list, command: str = "ADD") -> dict:
         """
         NASDAQ book orders
         :param keys: list of keys to use (e.g. ["AMD", "CRWD"])
@@ -371,7 +395,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: str | list, fields: str | list, command="ADD") -> dict:
+    def options_book(self, keys: str | list, fields: str | list, command: str = "ADD") -> dict:
         """
         Options book orders
         :param keys: list of keys to use (e.g. ["GOOG  240809C00095000", "AAPL  240517P00190000"])
@@ -385,7 +409,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: str | list, fields: str | list, command="ADD") -> dict:
+    def chart_equity(self, keys: str | list, fields: str | list, command: str = "ADD") -> dict:
         """
         Chart equity
         :param keys: list of keys to use (e.g. ["GOOG", "AAPL"])
@@ -399,7 +423,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: str | list, fields: str | list, command="ADD") -> dict:
+    def chart_futures(self, keys: str | list, fields: str | list, command: str = "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"])
@@ -413,7 +437,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: str | list, fields: str | list, command="ADD") -> dict:
+    def screener_equity(self, keys: str | list, fields: str | list, command: str = "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"])
@@ -427,7 +451,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_options(self, keys: str | list, fields: str | list, command="ADD") -> dict:
+    def screener_options(self, keys: str | list, fields: str | list, command: str = "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"])
@@ -441,7 +465,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") -> dict:
+    def account_activity(self, keys="Account Activity", fields="0,1,2,3", command: str = "SUBS") -> dict:
         """
         Account activity
         :param keys: list of keys to use (e.g. ["Account Activity"])

{schwabdev-2.2.2 → schwabdev-2.2.4}/schwabdev.egg-info/PKG-INFO RENAMED Viewed

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schwabdev
-Version: 2.2.2
+Version: 2.2.4
 Summary: An easy and lightweight wrapper for using the Charles Schwab API.
 Author: Tyler Bowers
 Author-email: tylerebowers@gmail.com
@@ -28,20 +28,22 @@ This is an unofficial python program to access the Schwab api.
 [Discord](https://discord.gg/m7SSjr9rs9), [PyPI](https://pypi.org/project/schwabdev/), [Youtube](https://youtube.com/playlist?list=PLs4JLWxBQIxpbvCj__DjAc0RRTlBz-TR8), [Github](https://github.com/tylerebowers/Schwab-API-Python).
 ## Installation
-`pip install schwabdev requests websockets`
+`pip install schwabdev`
 *You may need to use `pip3` instead of `pip`*
 ## Quick setup
 1. Setup your Schwab developer account [here](https://beta-developer.schwab.com/).
    - Create a new Schwab individual developer app with callback url "https://127.0.0.1" (case sensitive)
+   - Add both API products to your app: "Accounts and Trading Production" and "Market Data Production".
    - Wait until the status is "Ready for use", note that "Approved - Pending" will not work.
    - Enable TOS (Thinkorswim) for your Schwab account, it is needed for orders and other api calls.
 2. Install packages
-   - Install schwabdev and requirements `pip install schwabdev requests websockets`
+   - Install schwabdev and requirements `pip install schwabdev`
    - *You may need to use `pip3` instead of `pip`*
 3. Examples on how to use the client are in the `examples/` folder (add your keys in the .env file)
-   - The first time you run you will have to sign in to your Schwab account using the generated link in the terminal. After signing in, agree to the terms, and select account(s). Then you will have to copy the link in the address bar and paste it into the terminal.
-   - Questions? - join the [Discord group](https://discord.gg/m7SSjr9rs9).
+   - The first time you run you will have to sign in to your Schwab account using the generated link in the terminal.
+   - After signing in, agree to the terms, and select account(s). Then you will have to copy the link in the address bar and paste it into the terminal.
+   - Questions? - join the [Discord group](https://discord.gg/m7SSjr9rs9) or consult the `/docs` folder.
 ```py
 import schwabdev #import the package

{schwabdev-2.2.2 → schwabdev-2.2.4}/schwabdev.egg-info/SOURCES.txt RENAMED Viewed

@@ -1,5 +1,6 @@
 LICENSE.txt
 README.md
+pyproject.toml
 setup.py
 schwabdev/__init__.py
 schwabdev/api.py

{schwabdev-2.2.2 → schwabdev-2.2.4}/setup.py RENAMED Viewed

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
-VERSION = '2.2.2'
+VERSION = '2.2.4' # Also update version in api.py
 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.2 → schwabdev-2.2.4}/LICENSE.txt RENAMED Viewed

File without changes

{schwabdev-2.2.2 → schwabdev-2.2.4}/schwabdev/__init__.py RENAMED Viewed

File without changes

{schwabdev-2.2.2 → schwabdev-2.2.4}/schwabdev.egg-info/dependency_links.txt RENAMED Viewed

File without changes

{schwabdev-2.2.2 → schwabdev-2.2.4}/schwabdev.egg-info/requires.txt RENAMED Viewed

File without changes

{schwabdev-2.2.2 → schwabdev-2.2.4}/schwabdev.egg-info/top_level.txt RENAMED Viewed

File without changes

{schwabdev-2.2.2 → schwabdev-2.2.4}/setup.cfg RENAMED Viewed

File without changes

schwabdev 2.2.2__tar.gz → 2.2.4__tar.gz

schwabdev 2.2.2tar.gz → 2.2.4tar.gz