schwabdev 2.2.2__tar.gz → 2.2.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schwabdev
-Version: 2.2.2
+Version: 2.2.3
 Summary: An easy and lightweight wrapper for using the Charles Schwab API.
 Author: Tyler Bowers
 Author-email: tylerebowers@gmail.com

schwabdev-2.2.3/pyproject.toml

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

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

@@ -74,14 +74,14 @@ 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)")
+                print(self._access_token_issued.strftime("[Schwabdev] 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("[Schwabdev] Refresh token last updated: %Y-%m-%d %H:%M:%S") + f" (expires in {self._refresh_token_timeout - (datetime.datetime.now(datetime.timezone.utc) - self._refresh_token_issued).days} days)")
             # check if tokens need to be updated and update if needed
             self.update_tokens()
         else:
             # 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 +91,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):
         """
@@ -106,16 +106,16 @@ class Client:
         :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!")
+            print("[Schwabdev] The refresh token has expired, please update!")
             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.")
+            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 +136,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 +149,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,10 +166,10 @@ 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)")
 
@@ -516,7 +516,7 @@ class Client:
         :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)

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

@@ -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)
@@ -49,15 +48,16 @@ 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")
 
         # 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",
@@ -87,17 +87,16 @@ class Stream:
             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):
         """
@@ -113,9 +112,9 @@ class Stream:
             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):
         """
         Start the stream automatically at market open and close, will NOT erase subscriptions
         :param receiver: function to call when data is received
@@ -125,30 +124,30 @@ 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(11, 59, 0, tzinfo=datetime.timezone.utc)
         if after_hours:
-            end = time(20, 0, 0)
+            end = datetime.time(24, 0, 0, tzinfo=datetime.timezone.utc)
 
         def checker():
 
             while True:
-                in_hours = (start <= datetime.now().time() <= end) and (0 <= datetime.now().weekday() <= 4)
+                in_hours = (start <= datetime.datetime.now(datetime.timezone.utc).time() <= end) and (0 <= datetime.datetime.now(datetime.timezone.utc).weekday() <= 4)
                 if in_hours and not self.active:
                     if len(self.subscriptions) == 0:
-                        if self.verbose: print("No subscriptions, starting stream anyways.")
+                        if self._client.verbose: print("[Schwabdev] No subscriptions, starting stream anyways.")
                     self.start(receiver=receiver)
                 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)
 
         threading.Thread(target=checker).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() <= end:
+            print("[Schwabdev] Stream was started outside of active hours and will launch when in hours.")
 
     def _record_request(self, request):
         """
@@ -211,7 +210,30 @@ 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.")
+
+
+    async def send_async(self, requests):
+        """
+        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=True):
@@ -242,24 +264,23 @@ 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):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: schwabdev
-Version: 2.2.2
+Version: 2.2.3
 Summary: An easy and lightweight wrapper for using the Charles Schwab API.
 Author: Tyler Bowers
 Author-email: tylerebowers@gmail.com

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

@@ -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.3}/setup.py

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