schwabdev 1.0.0__tar.gz

schwabdev-1.0.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.1
+Name: schwabdev
+Version: 1.0.0
+Summary: Schwab API Python Client (unofficial)
+Author: Tyler Bowers
+Author-email: tylerebowers@gmail.com
+License: MIT
+Project-URL: Source, https://github.com/tylerebowers/Schwab-API-Python
+Project-URL: Youtube, https://www.youtube.com/playlist?list=PLs4JLWxBQIxpbvCj__DjAc0RRTlBz-TR8
+Project-URL: PyPI, https://pypi.org/project/schwabdev/
+Keywords: python,schwab,api,client,finance,trading,stocks,equities,options,forex,futures
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Schwab-API-Python 
+This is an unofficial python program to access the Schwab api.    
+You will need a Schwab developer account [here](https://beta-developer.schwab.com/).  
+Join the [Discord group](https://discord.gg/m7SSjr9rs9).  
+Also found on [PyPI](https://pypi.org/project/schwabdev/), install via `pip3 install schwabdev` 
+
+
+## Quick setup
+1. Create a new Schwab individual developer app with callback url "https://127.0.0.1" (case sensitive) and wait until the status is "Ready for use", note that "Approved - Pending" will not work.
+2. Enable TOS (Thinkorswim) for your Schwab account, it is needed for orders and other api calls.
+3. Python version 3.11 or higher is required.     
+4. `pip3 install schwabdev requests websockets tk` (tkinter/tk may need to be installed differently)
+5. Import the package `import schwabdev`
+6. Create a client `client = schwabdev.Client('Your app key', 'Your app secret')`
+7. Examples on how to use the client are in `tests/api_demo.py`
+
+## What can this program do?
+ - Authenticate and access the api 
+ - Functions for all api functions (examples in `tests/api_demo.py`)
+ - Auto "access token" updates (`client.update_tokens_auto()`)
+ - Stream real-time data with customizable response handler (examples in `tests/stream_demo.py`)
+ ### TBD 
+ - Automatic refresh token updates. (Waiting for Schwab implementation)
+
+## Notes
+
+The schwabdev folder contains code for main operations:     
+ - `api.py` contains functions relating to api calls, requests, and automatic token checker threads.
+ - `stream.py` contains functions for streaming data from websockets.
+ - `terminal.py` contains a program for making additional terminal windows and printing to the terminal with color.
+
+## License (MIT)
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

schwabdev-1.0.0/README.md

@@ -0,0 +1,40 @@
+# Schwab-API-Python 
+This is an unofficial python program to access the Schwab api.    
+You will need a Schwab developer account [here](https://beta-developer.schwab.com/).  
+Join the [Discord group](https://discord.gg/m7SSjr9rs9).  
+Also found on [PyPI](https://pypi.org/project/schwabdev/), install via `pip3 install schwabdev` 
+
+
+## Quick setup
+1. Create a new Schwab individual developer app with callback url "https://127.0.0.1" (case sensitive) and wait until the status is "Ready for use", note that "Approved - Pending" will not work.
+2. Enable TOS (Thinkorswim) for your Schwab account, it is needed for orders and other api calls.
+3. Python version 3.11 or higher is required.     
+4. `pip3 install schwabdev requests websockets tk` (tkinter/tk may need to be installed differently)
+5. Import the package `import schwabdev`
+6. Create a client `client = schwabdev.Client('Your app key', 'Your app secret')`
+7. Examples on how to use the client are in `tests/api_demo.py`
+
+## What can this program do?
+ - Authenticate and access the api 
+ - Functions for all api functions (examples in `tests/api_demo.py`)
+ - Auto "access token" updates (`client.update_tokens_auto()`)
+ - Stream real-time data with customizable response handler (examples in `tests/stream_demo.py`)
+ ### TBD 
+ - Automatic refresh token updates. (Waiting for Schwab implementation)
+
+## Notes
+
+The schwabdev folder contains code for main operations:     
+ - `api.py` contains functions relating to api calls, requests, and automatic token checker threads.
+ - `stream.py` contains functions for streaming data from websockets.
+ - `terminal.py` contains a program for making additional terminal windows and printing to the terminal with color.
+
+## License (MIT)
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

schwabdev-1.0.0/schwabdev/__init__.py

@@ -0,0 +1 @@
+from .api import Client

schwabdev-1.0.0/schwabdev/api.py

@@ -0,0 +1,393 @@
+import json
+import base64
+import requests
+import threading
+import urllib.parse
+from .stream import Stream
+from datetime import datetime
+from schwabdev import terminal
+
+
+class Client:
+
+    def __init__(self, app_key, app_secret, callback_url="https://127.0.0.1", tokens_file="tokens.json"):
+        if app_key is None or app_secret is None or callback_url is None or tokens_file is None:
+            raise Exception("app_key, app_secret, callback_url, and tokens_file cannot be None.")
+        elif len(app_key) != 32 or len(app_secret) != 16:
+            raise Exception("App key or app secret invalid length.")
+
+        self._app_key = app_key
+        self._app_secret = app_secret
+        self._callback_url = callback_url
+        self.access_token = None
+        self.refresh_token = None
+        self.id_token = None
+        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.stream = Stream(self)
+
+        # Try to load tokens from the tokens file
+        at_issued, rt_issued, token_dictionary = self._read_tokens_file()
+        if None not in [at_issued, rt_issued, token_dictionary]:
+            # show user when tokens were last updated and when they will expire
+            self.access_token = token_dictionary.get("access_token")
+            self.refresh_token = token_dictionary.get("refresh_token")
+            self.id_token = token_dictionary.get("id_token")
+            self._access_token_issued = at_issued
+            self._refresh_token_issued = rt_issued
+            terminal.color_print.info(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)")
+            terminal.color_print.info(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)")
+            # check if tokens need to be updated and update if needed
+            self.update_tokens()
+        else:
+            # The tokens file doesn't exist, so create it.
+            terminal.color_print.warning(f"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()
+
+        # get account numbers & hashes, this doubles as a checker to make sure that the appKey and appSecret are valid and that the app is ready for use
+        resp = self.account_linked()
+        if resp.ok:
+            d = resp.json()
+            terminal.color_print.info(f"Linked Accounts: {d}")
+        else:  # app might not be "Ready For Use"
+            terminal.color_print.error("Could not get linked accounts.")
+            terminal.color_print.error("Please make sure that your app status is \"Ready For Use\" and that the app key and app secret are valid.")
+            terminal.color_print.error(resp.json())
+        resp.close()
+
+        terminal.color_print.info("Initialization Complete")
+
+    def update_tokens(self):
+        if (datetime.now() - self._refresh_token_issued).days >= (
+                self._refresh_token_timeout - 1):  # check if we need to update refresh (and access) token
+            for i in range(5):  terminal.color_print.user("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 - 60)):  # check if we need to update access token
+            terminal.color_print.info("The access token has expired, updating automatically.")
+            self._update_access_token()
+        # else: terminal.color_print.info("Token check passed")
+
+    def update_tokens_auto(self):
+        def checker():
+            import time
+            while True:
+                self.update_tokens()
+                time.sleep(60)
+
+        threading.Thread(target=checker, daemon=True).start()
+
+    # "refresh" the access token using the refresh token
+    def _update_access_token(self):
+        # get the token dictionary (we will need to rewrite the file)
+        access_token_time_old, refresh_token_issued, token_dictionary_old = self._read_tokens_file()
+        # get new tokens
+        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._refresh_token_issued = refresh_token_issued
+            new_td = response.json()
+            self.access_token = new_td.get("access_token")
+            self.refresh_token = new_td.get("refresh_token")
+            self.id_token = new_td.get("id_token")
+            self._write_tokens_file(self._access_token_issued, refresh_token_issued, new_td)
+            # show user that we have updated the access token
+            terminal.color_print.info(f"Access token updated: {self._access_token_issued}")
+        else:
+            terminal.color_print.error("Could not get new access token.")
+
+    # get new access and refresh tokens using authorization code.
+    def _update_refresh_token(self):
+        import webbrowser
+        # get authorization code (requires user to authorize)
+        terminal.color_print.user("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}'
+        terminal.color_print.user(f"Click to authenticate: {auth_url}")
+        terminal.color_print.user("Opening browser..")
+        webbrowser.open(auth_url)
+        response_url = terminal.color_print.input(
+            "After authorizing, wait for it to load (<1min) and paste the WHOLE url here: ")
+        code = f"{response_url[response_url.index('code=') + 5:response_url.index('%40')]}@"  # session = responseURL[responseURL.index("session=")+8:]
+        # get new access and refresh tokens
+        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()
+            new_td = response.json()
+            self.access_token = new_td.get("access_token")
+            self.refresh_token = new_td.get("refresh_token")
+            self.id_token = new_td.get("id_token")
+            self._write_tokens_file(self._access_token_issued, self._refresh_token_issued, new_td)
+            terminal.color_print.info("Refresh and Access tokens updated")
+        else:
+            terminal.color_print.error("Could not get new refresh and access tokens.")
+            terminal.color_print.error(
+                "Please make sure that your app status is \"Ready For Use\" and that the app key and app secret are valid.")
+
+    def _post_oauth_token(self, grant_type, code):
+        headers = {
+            'Authorization': f'Basic {base64.b64encode(bytes(f"{self._app_key}:{self._app_secret}", "utf-8")).decode("utf-8")}',
+            'Content-Type': 'application/x-www-form-urlencoded'}
+        if grant_type == 'authorization_code':  # gets access and refresh tokens using authorization code
+            data = {'grant_type': 'authorization_code', 'code': code,
+                    'redirect_uri': self._callback_url}
+        elif grant_type == 'refresh_token':  # refreshes the access token
+            data = {'grant_type': 'refresh_token', 'refresh_token': code}
+        else:
+            terminal.color_print.error("Invalid grant type")
+            return None
+        return requests.post('https://api.schwabapi.com/v1/oauth/token', headers=headers, data=data)
+
+    def _write_tokens_file(self, atIssued, rtIssued, tokenDictionary):
+        # update tokens file
+        try:
+            with open(self._tokens_file, 'w') as f:
+                toWrite = {"access_token_issued": atIssued.isoformat(), "refresh_token_issued": rtIssued.isoformat(),
+                           "token_dictionary": tokenDictionary}
+                json.dump(toWrite, f, ensure_ascii=False, indent=4)
+                f.flush()
+        except Exception as e:
+            terminal.color_print.error(e)
+
+
+    def _read_tokens_file(self):
+        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")
+        except Exception as e:
+            terminal.color_print.error(e)
+            return None, None, None
+
+    def _params_parser(self, params):
+        for key in list(params.keys()):
+            if params[key] is None: del params[key]
+        return params
+
+    def _time_convert(self, dt=None, form="8601"):
+        if dt is None:
+            return None
+        elif dt is str:
+            return dt
+        elif form == "8601":  # assume datetime object from here on
+            return f'{dt.isoformat()[:-3]}Z'
+        elif form == "epoch":
+            return int(dt.timestamp())
+        elif form == "epoch_ms":
+            return int(dt.timestamp() * 1000)
+        elif form == "YYYY-MM-DD":
+            return dt.strftime("%Y-%M-%d")
+        else:
+            return dt
+
+    def _format_list(self, l):
+        if l is None:
+            return None
+        elif type(l) is list:
+            return ",".join(l)
+        else:
+            return l
+        
+    _base_api_url = "https://api.schwabapi.com"
+
+    """
+    Accounts and Trading Production
+    """
+
+    # Get account numbers and account hashes for linked accounts
+    def account_linked(self):
+        return requests.get(f'{self._base_api_url}/trader/v1/accounts/accountNumbers',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            timeout=2)
+
+    # Get account details for all linked accounts, details such as balance, positions, buying power, etc.
+    def account_details_all(self, fields=None):
+        return requests.get(f'{self._base_api_url}/trader/v1/accounts/',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser({'fields': fields}),
+                            timeout=2)
+
+    # Get account details for one linked account, uses default account.
+    def account_details(self, accountHash, fields=None):
+        return requests.get(f'{self._base_api_url}/trader/v1/accounts/{accountHash}',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser({'fields': fields}),
+                            timeout=2)
+
+    # Get all orders for one linked account, uses default account.
+    def account_orders(self, accountHash, maxResults, fromEnteredTime, toEnteredTime, status=None):
+        return requests.get(f'{self._base_api_url}/trader/v1/accounts/{accountHash}/orders',
+                            headers={"Accept": "application/json", 'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser(
+                                {'maxResults': maxResults, 'fromEnteredTime': self._time_convert(fromEnteredTime, "8601"),
+                                 'toEnteredTime': self._time_convert(toEnteredTime, "8601"), 'status': status}),
+                            timeout=2)
+
+    # place an order for one linked account (uses default account)
+    def order_place(self, accountHash, order):
+        return requests.post(f'{self._base_api_url}/trader/v1/accounts/{accountHash}/orders',
+                             headers={"Accept": "application/json", 'Authorization': f'Bearer {self.access_token}',
+                                      "Content-Type": "application/json"},
+                             json=order,
+                             timeout=2)
+
+    # get order details using order id (uses default account)
+    def order_details(self, accountHash, orderId):
+        return requests.get(f'{self._base_api_url}/trader/v1/accounts/{accountHash}/orders/{orderId}',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            timeout=2)
+
+    # cancel order using order id (uses default account)
+    def order_cancel(self, accountHash, orderId):
+        return requests.delete(f'{self._base_api_url}/trader/v1/accounts/{accountHash}/orders/{orderId}',
+                               headers={'Authorization': f'Bearer {self.access_token}'},
+                               timeout=2)
+
+    # replace order using order id (uses default account)
+    def order_replace(self, accountHash, orderId, order):
+        return requests.put(f'{self._base_api_url}/trader/v1/accounts/{accountHash}/orders/{orderId}',
+                            headers={"Accept": "application/json", 'Authorization': f'Bearer {self.access_token}',
+                                     "Content-Type": "application/json"},
+                            json=order,
+                            timeout=2)
+
+    # get all orders across all linked accounts
+    def account_orders_all(self, maxResults, fromEnteredTime, toEnteredTime, status=None):
+        return requests.get(f'{self._base_api_url}/trader/v1/orders',
+                            headers={"Accept": "application/json", 'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser(
+                                {'maxResults': maxResults, 'fromEnteredTime': self._time_convert(fromEnteredTime, "8601"),
+                                 'toEnteredTime': self._time_convert(toEnteredTime, "8601"), 'status': status}),
+                            timeout=2)
+
+    """ #COMING SOON (waiting on Schwab)
+      # /accounts/{accountHash}/previewOrder
+    def order_preview(accountHash, orderObject):
+        
+        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)
+
+    """
+
+    # get all transactions (has maximums) for one linked account (uses default account)
+    def transactions(self, accountHash, startDate, endDate, types, symbol=None):
+        return requests.get(f'{self._base_api_url}/trader/v1/accounts/{accountHash}/transactions',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser(
+                                {'accountNumber': accountHash, 'startDate': self._time_convert(startDate, "8601"),
+                                 'endDate': self._time_convert(endDate, "8601"), 'symbol': symbol, 'types': types}),
+                            timeout=2)
+
+    # get transaction details using transaction id (uses default account)
+    def transaction_details(self, accountHash, transactionId):
+        return requests.get(f'{self._base_api_url}/trader/v1/accounts/{accountHash}/transactions/{transactionId}',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params={'accountNumber': accountHash, 'transactionId': transactionId},
+                            timeout=2)
+
+    # get user preferences, includes streaming info
+    def preferences(self):
+        return requests.get(f'{self._base_api_url}/trader/v1/userPreference',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            timeout=2)
+
+    """
+    Market Data
+    """
+    
+    # get quotes for a list of tickers
+    def quotes(self, symbols=None, fields=None, indicative=False):
+        return requests.get(f'{self._base_api_url}/marketdata/v1/quotes',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser(
+                                {'symbols': self._format_list(symbols), 'fields': fields, 'indicative': indicative}),
+                            timeout=2)
+
+    # get a single quote for a ticker
+    def quote(self, symbol_id, fields=None):
+        return requests.get(f'{self._base_api_url}/marketdata/v1/{urllib.parse.quote(symbol_id)}/quotes',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser({'fields': fields}),
+                            timeout=2)
+
+    # get option chains for a ticker
+    def option_chains(self, symbol, contractType=None, strikeCount=None, includeUnderlyingQuotes=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):
+        return requests.get(f'{self._base_api_url}/marketdata/v1/chains',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser(
+                                {'symbol': symbol, 'contractType': contractType, 'strikeCount': strikeCount,
+                                 'includeUnderlyingQuotes': includeUnderlyingQuotes, 'strategy': strategy,
+                                 'interval': interval, 'strike': strike, 'range': range, 'fromDate': fromDate,
+                                 'toDate': toDate, 'volatility': volatility, 'underlyingPrice': underlyingPrice,
+                                 'interestRate': interestRate, 'daysToExpiration': daysToExpiration,
+                                 'expMonth': expMonth, 'optionType': optionType, 'entitlement': entitlement}),
+                            timeout=2)
+
+    # get an option expiration chain for a ticker
+    def option_expiration_chain(self, symbol):
+        return requests.get(f'{self._base_api_url}/marketdata/v1/expirationchain',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser({'symbol': symbol}),
+                            timeout=2)
+
+    # get price history for a ticker
+    def price_history(self, symbol, periodType=None, period=None, frequencyType=None, frequency=None, startDate=None,
+                      endDate=None, needExtendedHoursData=None, needPreviousClose=None):
+        return requests.get(f'{self._base_api_url}/marketdata/v1/pricehistory',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser({'symbol': symbol, 'periodType': periodType, 'period': period,
+                                                        'frequencyType': frequencyType, 'frequency': frequency,
+                                                        'startDate': self._time_convert(startDate, 'epoch_ms'),
+                                                        'endDate': self._time_convert(endDate, 'epoch_ms'),
+                                                        'needExtendedHoursData': needExtendedHoursData,
+                                                        'needPreviousClose': needPreviousClose}),
+                            timeout=2)
+
+    # get movers in a specific index and direction
+    def movers(self, symbol, sort=None, frequency=None):
+        return requests.get(f'{self._base_api_url}/marketdata/v1/movers/{symbol}',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser({'sort': sort, 'frequency': frequency}),
+                            timeout=2)
+
+    # get market hours for a list of markets
+    def market_hours(self, symbols, date=None):
+        return requests.get(f'{self._base_api_url}/marketdata/v1/markets',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser(
+                                {'markets': symbols, #self._format_list(symbols),
+                                 'date': self._time_convert(date, 'YYYY-MM-DD')}),
+                            timeout=2)
+
+    # get market hours for a single market
+    def market_hour(self, market_id, date=None):
+        return requests.get(f'{self._base_api_url}/marketdata/v1/markets/{market_id}',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params=self._params_parser({'date': self._time_convert(date, 'YYYY-MM-DD')}),
+                            timeout=2)
+
+    # get instruments for a list of symbols
+    def instruments(self, symbol, projection):
+        return requests.get(f'{self._base_api_url}/marketdata/v1/instruments',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            params={'symbol': symbol, 'projection': projection},
+                            timeout=2)
+
+    # get instruments for a single cusip
+    def instrument_cusip(self, cusip_id):
+        return requests.get(f'{self._base_api_url}/marketdata/v1/instruments/{cusip_id}',
+                            headers={'Authorization': f'Bearer {self.access_token}'},
+                            timeout=2)

schwabdev-1.0.0/schwabdev/stream.py

@@ -0,0 +1,304 @@
+"""
+This file contains functions to stream data
+Coded by Tyler Bowers
+Github: https://github.com/tylerebowers/Schwab-API-Python
+"""
+
+import json
+import asyncio
+import threading
+import websockets
+import websockets.exceptions
+from time import sleep
+from datetime import datetime, time
+from schwabdev import terminal
+
+
+class Stream:
+
+    def __init__(self, client):
+        self._websocket = None
+        self._streamer_info = None
+        self._start_timestamp = None
+        self._terminal = None
+        self._request_id = 0  # a counter for the request id
+        self._queue = []  # a queue of requests to be sent
+        self.active = False
+        self.client = client  # so we can get streamer info
+
+    async def _start_streamer(self, receiver_func="default"):
+        # get streamer info
+        response = self.client.preferences()
+        if response.ok:
+            self._streamer_info = response.json().get('streamerInfo', None)[0]
+        else:
+            terminal.color_print.error("Could not get streamerInfo")
+
+        # specify receiver (what do we do with received data)
+        if receiver_func == "default":
+            if self._terminal is None:
+                self._terminal = terminal.multiTerminal(title="Stream output")
+
+            def default_receiver(data):
+                self._terminal.print(data)
+            receiver_func = default_receiver
+
+        # start the stream
+        while True:
+            try:
+                self._start_timestamp = datetime.now()
+                terminal.color_print.info("Connecting to streaming server -> ", end="")
+                async with websockets.connect(self._streamer_info.get('streamerSocketUrl'), ping_interval=None) as self._websocket:
+                    print("Connected.")
+                    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())
+                    self.active = True
+                    # send queued requests
+                    while self._queue:
+                        await self._websocket.send(json.dumps({"requests": self._queue.pop(0)}))
+                        receiver_func(await self._websocket.recv())
+                    # TODO: resend requests if the stream crashes
+                    while True:
+                        receiver_func(await self._websocket.recv())
+            except Exception as e:
+                self.active = False
+                terminal.color_print.error(f"{e}")
+                if e is websockets.exceptions.ConnectionClosedOK:
+                    terminal.color_print.info("Stream has closed.")
+                    break
+                elif e is RuntimeError:
+                    terminal.color_print.warning("Streaming window has closed.")
+                    break
+                elif (datetime.now() - self._start_timestamp).seconds < 60:
+                    terminal.color_print.error("Stream not alive for more than 1 minute, exiting...")
+                    break
+                else:
+                    terminal.color_print.warning("Connection lost to server, reconnecting...")
+
+    def start(self, receiver="default"):
+        def _start_async():
+            asyncio.run(self._start_streamer(receiver))
+
+        threading.Thread(target=_start_async).start()
+        sleep(4)  # wait for thread/stream to start
+
+
+    def start_automatic(self, after_hours=False, pre_hours=False):
+        start = time(9, 30, 0)  # market opens at 9:30
+        end = time(16, 0, 0)  # market closes at 4:00
+        if pre_hours:
+            start = time(8, 0, 0)
+        if after_hours:
+            end = time(20, 0, 0)
+
+        def checker():
+
+            while True:
+                in_hours = (start <= datetime.now().time() <= end) and (0 <= datetime.now().weekday() <= 4)
+                if in_hours and not self.active:
+                    self.start()
+                elif not in_hours and self.active:
+                    terminal.color_print.info("Stopping Stream.")
+                    self.stop()
+                sleep(60)
+
+        threading.Thread(target=checker).start()
+
+        if not start <= datetime.now().time() <= end:
+            terminal.color_print.info("Stream was started outside of active hours and will launch when in hours.")
+
+
+    def send(self, requests):
+        async def _send(toSend):
+            await self._websocket.send(toSend)
+        if type(requests) is not list:
+            requests = [requests]
+        if self.active:
+            toSend = json.dumps({"requests": requests})
+            asyncio.run(_send(toSend))
+        else:
+            terminal.color_print.warning("Stream is not active, request queued.")
+            self._queue.append(requests)
+
+    # TODO: Fix this (wont properly close)
+    def stop(self):
+        self._request_id += 1
+        self.send(self.basic_request(service="ADMIN", command="LOGOUT"))
+        self.active = False
+
+    def basic_request(self, service, command, parameters=None):
+        if self._streamer_info is None:
+            response = self.client.preferences()
+            if response.ok:
+                self._streamer_info = response.json().get('streamerInfo', None)[0]
+
+        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: request["parameters"] = parameters
+            self._request_id += 1
+            return request
+        else:
+            terminal.color_print.error("Could not get streamerInfo")
+            return None
+
+    @staticmethod
+    def _list_to_string(ls):
+        if type(ls) is str: return ls
+        elif type(ls) is list: return ",".join(map(str, ls))
+
+
+    # requests that can be sent to the stream
+    def chart_equity(self, keys, fields, command="SUBS"):
+        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="SUBS"):
+        return self.basic_request("CHART_FUTURES", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
+
+    def level_one_quote(self, keys, fields, command="SUBS"):  # Service not available or temporary down.
+        return self.basic_request("QUOTE", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
+
+    def level_one_option(self, keys, fields, command="SUBS"):
+        return self.basic_request("OPTION", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
+
+    def level_one_futures(self, keys, fields, command="SUBS"):
+        return self.basic_request("LEVELONE_FUTURES", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
+
+    def level_one_forex(self, keys, fields, command="SUBS"):
+        return self.basic_request("LEVELONE_FOREX", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
+
+    def level_one_futures_options(self, keys, fields, command="SUBS"):
+        return self.basic_request("LEVELONE_FUTURES_OPTIONS", command, parameters={"keys": Stream._list_to_string(keys), "fields": Stream._list_to_string(fields)})
+
+
+    """
+    
+    class account:
+        @staticmethod
+        def activity(keys, fields, command="SUBS"):
+            return Stream.request(command, "ACCT_ACTIVITY", keys, fields)
+    
+    
+    class actives:
+        @staticmethod
+        def nasdaq(keys, fields, command="SUBS"):
+            return Stream.request(command, "ACTIVES_NASDAQ", keys, fields)
+    
+        @staticmethod
+        def nyse(keys, fields, command="SUBS"):
+            return Stream.request(command, "ACTIVES_NYSE", keys, fields)
+    
+        @staticmethod
+        def otcbb(keys, fields, command="SUBS"):
+            return Stream.request(command, "ACTIVES_OTCBB", keys, fields)
+    
+        @staticmethod
+        def options(keys, fields, command="SUBS"):
+            return Stream.request(command, "ACTIVES_OPTIONS", keys, fields)
+    
+    
+    
+    class book:
+        @staticmethod
+        def forex(keys, fields, command="SUBS"):
+            return Stream.request(command, "FOREX_BOOK", keys, fields)
+    
+        @staticmethod
+        def futures(keys, fields, command="SUBS"):
+            return Stream.request(command, "FUTURES_BOOK", keys, fields)
+    
+        @staticmethod
+        def listed(keys, fields, command="SUBS"):
+            return Stream.request(command, "LISTED_BOOK", keys, fields)
+    
+        @staticmethod
+        def nasdaq(keys, fields, command="SUBS"):
+            return Stream.request(command, "NASDAQ_BOOK", keys, fields)
+    
+        @staticmethod
+        def options(keys, fields, command="SUBS"):
+            return Stream.request(command, "OPTIONS_BOOK", keys, fields)
+    
+        @staticmethod
+        def futures_options(keys, fields, command="SUBS"):
+            return Stream.request(command, "FUTURES_OPTIONS_BOOK", keys, fields)
+    
+    
+    class levelTwo:
+        @staticmethod
+        def _NA():
+            print("Not Available")
+    
+    
+    class news:
+        @staticmethod
+        def headline(keys, fields, command="SUBS"):
+            return Stream.request(command, "NEWS_HEADLINE", keys, fields)
+    
+        @staticmethod
+        def headlineList(keys, fields, command="SUBS"):
+            return Stream.request(command, "NEWS_HEADLINELIST", keys, fields)
+    
+        @staticmethod
+        def headlineStory(keys, fields, command="SUBS"):
+            return Stream.request(command, "NEWS_STORY", keys, fields)
+    
+    
+    class timeSale:
+        @staticmethod
+        def equity(keys, fields, command="SUBS"):
+            return Stream.request(command, "TIMESALE_EQUITY", keys, fields)
+    
+        @staticmethod
+        def forex(keys, fields, command="SUBS"):
+            return Stream.request(command, "TIMESALE_FOREX", keys, fields)
+    
+        @staticmethod
+        def futures(keys, fields, command="SUBS"):
+            return Stream.request(command, "TIMESALE_FUTURES", keys, fields)
+    
+        @staticmethod
+        def options(keys, fields, command="SUBS"):
+            return Stream.request(command, "TIMESALE_OPTIONS", keys, fields)
+            
+    """
+
+"""
+
+def _streamResponseHandler(streamOut):
+    try:
+        parentDict = json.loads(streamOut)
+        for key in parentDict.keys():
+            match key:
+                case "notify":
+                    self._terminal.print(
+                        f"[Heartbeat]: {Stream.epochMSToDate(parentDict['notify'][0]['heartbeat'])}")
+                case "response":
+                    for resp in parentDict.get('response'):
+                        self._terminal.print(f"[Response]: {resp}")
+                case "snapshot":
+                    for snap in parentDict.get('snapshot'):
+                        self._terminal.print(f"[Snapshot]: {snap}")
+                case "data":
+                    for data in parentDict.get("data"):
+                        if data.get('service').upper() in universe.streamFieldAliases:
+                            service = data.get("service")
+                            timestamp = data.get("timestamp")
+                            for symbolData in data.get("content"):
+                                tempSnapshot = database.Snapshot(service, symbolData.get("key"), timestamp, symbolData)
+                                if universe.preferences.usingDatabase:
+                                    database.DBAddSnapshot(tempSnapshot)  # add to database
+                                if universe.preferences.usingDataframes:
+                                    database.DFAddSnapshot(tempSnapshot)  # add to dataframes
+                                self._terminal.print(
+                                    f"[Data]: {tempSnapshot.toPrettyString()}")  # to stream output
+                case _:
+                    self._terminal.print(f"[Unknown Response]: {streamOut}")
+    except Exception as e:
+        self._terminal.print(f"[ERROR]: There was an error in decoding the stream response: {streamOut}")
+        self._terminal.print(f"[ERROR]: The error was: {e}")
+"""

schwabdev-1.0.0/schwabdev/terminal.py

@@ -0,0 +1,89 @@
+"""
+This file is used to print colored text and create multiple terminals
+Github: https://github.com/tylerebowers/Schwab-API-Python
+"""
+
+
+class color_print:
+    @staticmethod
+    def info(string, end="\n"): print(f"\033[92m{'[INFO]: '}\033[00m{string}", end=end)
+    @staticmethod
+    def warning(string, end="\n"): print(f"\033[93m{'[WARN]: '}\033[00m{string}", end=end)
+    @staticmethod
+    def error(string, end="\n"): print(f"\033[91m{'[ERROR]: '}\033[00m{string}", end=end)
+    @staticmethod
+    def user(string, end="\n"): print(f"\033[94m{'[USER]: '}\033[00m{string}", end=end)
+    @staticmethod
+    def input(string): return input(f"\033[94m{'[INPUT]: '}\033[00m{string}")
+
+
+from time import sleep
+import tkinter as tk
+from tkinter import ttk
+import threading
+
+
+class multiTerminal(threading.Thread):
+
+    def __init__(self, title="Terminal", height=20, width=200, font=("Courier New", "12"), backgroundColor="gray5", textColor="snow", allowClosing=True, ignoreClosedPrints=True):
+        #params
+        self.title = title
+        self.height = height
+        self.width = width
+        self.font = font
+        self.backgroundColor = backgroundColor
+        self.textColor = textColor
+        self.allowClosing = allowClosing
+        self.ignoreClosedPrints = ignoreClosedPrints
+        #internal variables
+        self._root = None  # main window
+        self._tb = None  # text box
+        self.isOpen = False  # if the window is open
+        self._safeExit = False  # if the window is safe to exit
+        threading.Thread.__init__(self, daemon=True)  # kill child thread on main thread exit
+        self.start()
+        sleep(0.5)  # wait for window to open
+
+    def close(self):
+        if self.isOpen and self._safeExit:  # safeExit is True is no operations are being done (i.e. print)
+            self.isOpen = False
+            self._root.quit()
+            self._root.update()
+            self._root = None
+
+    def run(self):
+        self._root = tk.Tk()
+        if self.allowClosing: self._root.protocol("WM_DELETE_WINDOW", self.close)
+        else: self._root.protocol("WM_DELETE_WINDOW", lambda: None)
+        self._root.title(self.title)
+        self._tb = tk.Text(self._root, height=self.height, width=self.width, wrap="none", font=self.font)
+        self._tb.pack(side="left", fill="both", expand=True)
+        self._tb.configure(state="disabled", bg=self.backgroundColor, fg=self.textColor)
+        sizegrip = ttk.Sizegrip(self._tb)
+        sizegrip.configure(cursor="sizing")
+        sizegrip.bind("<1>", self._resize_start)
+        sizegrip.bind("<B1-Motion>", self._resize_update)
+        self.isOpen = True
+        self._safeExit = True
+        self._root.mainloop()
+
+    def print(self, toPrint, end="\n"):
+        if self._root is None or not self.isOpen:
+            if not self.ignoreClosedPrints: return print(f"Terminal \"{self.title}\" is closed")
+            #if not self.ignoreClosedPrints: raise Exception(f"Terminal \"{self.title}\" is closed")
+        else:
+            self._safeExit = False  # needed so that we don't kill mainloop while printing
+            self._tb.configure(state="normal")
+            self._tb.insert("end", f"{toPrint}{end}")
+            self._tb.see("end")
+            self._tb.configure(state="disabled")
+            self._safeExit = True
+
+    def _resize_start(self, event):
+        self._x = event.x
+        self._y = event.y
+
+    def _resize_update(self, event):
+        delta_x = event.x - self._x
+        delta_y = event.y - self._y
+        self._tb.place_configure(width=self._tb.winfo_width() + delta_x, height=self._tb.winfo_height() + delta_y)

schwabdev-1.0.0/schwabdev.egg-info/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.1
+Name: schwabdev
+Version: 1.0.0
+Summary: Schwab API Python Client (unofficial)
+Author: Tyler Bowers
+Author-email: tylerebowers@gmail.com
+License: MIT
+Project-URL: Source, https://github.com/tylerebowers/Schwab-API-Python
+Project-URL: Youtube, https://www.youtube.com/playlist?list=PLs4JLWxBQIxpbvCj__DjAc0RRTlBz-TR8
+Project-URL: PyPI, https://pypi.org/project/schwabdev/
+Keywords: python,schwab,api,client,finance,trading,stocks,equities,options,forex,futures
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Schwab-API-Python 
+This is an unofficial python program to access the Schwab api.    
+You will need a Schwab developer account [here](https://beta-developer.schwab.com/).  
+Join the [Discord group](https://discord.gg/m7SSjr9rs9).  
+Also found on [PyPI](https://pypi.org/project/schwabdev/), install via `pip3 install schwabdev` 
+
+
+## Quick setup
+1. Create a new Schwab individual developer app with callback url "https://127.0.0.1" (case sensitive) and wait until the status is "Ready for use", note that "Approved - Pending" will not work.
+2. Enable TOS (Thinkorswim) for your Schwab account, it is needed for orders and other api calls.
+3. Python version 3.11 or higher is required.     
+4. `pip3 install schwabdev requests websockets tk` (tkinter/tk may need to be installed differently)
+5. Import the package `import schwabdev`
+6. Create a client `client = schwabdev.Client('Your app key', 'Your app secret')`
+7. Examples on how to use the client are in `tests/api_demo.py`
+
+## What can this program do?
+ - Authenticate and access the api 
+ - Functions for all api functions (examples in `tests/api_demo.py`)
+ - Auto "access token" updates (`client.update_tokens_auto()`)
+ - Stream real-time data with customizable response handler (examples in `tests/stream_demo.py`)
+ ### TBD 
+ - Automatic refresh token updates. (Waiting for Schwab implementation)
+
+## Notes
+
+The schwabdev folder contains code for main operations:     
+ - `api.py` contains functions relating to api calls, requests, and automatic token checker threads.
+ - `stream.py` contains functions for streaming data from websockets.
+ - `terminal.py` contains a program for making additional terminal windows and printing to the terminal with color.
+
+## License (MIT)
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

schwabdev-1.0.0/schwabdev.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+setup.py
+schwabdev/__init__.py
+schwabdev/api.py
+schwabdev/stream.py
+schwabdev/terminal.py
+schwabdev.egg-info/PKG-INFO
+schwabdev.egg-info/SOURCES.txt
+schwabdev.egg-info/dependency_links.txt
+schwabdev.egg-info/requires.txt
+schwabdev.egg-info/top_level.txt

schwabdev-1.0.0/schwabdev.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

schwabdev-1.0.0/schwabdev.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests
+websockets

schwabdev-1.0.0/schwabdev.egg-info/top_level.txt

@@ -0,0 +1 @@
+schwabdev

schwabdev-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

schwabdev-1.0.0/setup.py

@@ -0,0 +1,37 @@
+from setuptools import setup, find_packages
+
+VERSION = '1.0.0'
+DESCRIPTION = 'Schwab API Python Client (unofficial)'
+with open('README.md', 'r') as f:
+    LONG_DESCRIPTION = f.read()
+
+setup(
+    name='schwabdev',
+    version=VERSION,
+    author='Tyler Bowers',
+    author_email='tylerebowers@gmail.com',
+    license='MIT',
+    description=DESCRIPTION,
+    long_description=LONG_DESCRIPTION,
+    long_description_content_type='text/markdown',
+    packages=find_packages(),
+    python_requires='>=3.11',
+    install_requires=[
+        'requests',
+        'websockets',
+    ],
+    keywords=['python', 'schwab', 'api', 'client', 'finance', 'trading', 'stocks', 'equities', 'options', 'forex', 'futures'],
+    classifiers=[
+        'Topic :: Office/Business :: Financial :: Investment',
+        'License :: OSI Approved :: MIT License',
+        'Programming Language :: Python :: 3',
+        'Operating System :: OS Independent',
+        'Intended Audience :: Developers',
+        'Natural Language :: English',
+    ],
+    project_urls={
+        'Source': 'https://github.com/tylerebowers/Schwab-API-Python',
+        'Youtube': 'https://www.youtube.com/playlist?list=PLs4JLWxBQIxpbvCj__DjAc0RRTlBz-TR8',
+        'PyPI': 'https://pypi.org/project/schwabdev/'
+    }
+)