changes from mosting everything works on main

Author: Cfomodz

pythonic_schwab_api/algo_example_script.py

@@ -51,6 +51,9 @@ def actually_do_some_trading(orders_api, account_hash, valid_quotes):
 
 
 def find_trades_from_quotes(orders_api, quotes, account_hash):
+    if not quotes or len(quotes) == 0:
+        print("No quotes found.")
+        return
     # Convert quotes to DataFrame
     quotes_df = pd.DataFrame.from_dict(quotes, orient='index')
     quotes_df.index = quotes_df.index.map(urll.unquote)
@@ -61,6 +64,9 @@ def find_trades_from_quotes(orders_api, quotes, account_hash):
     # Filter out quotes with missing data
     quotes_df = quotes_df.dropna(subset=['askPrice', 'askSize', 'bidPrice', 'bidSize', 'lastPrice'])
 
+    if 'regular' not in quotes_df.columns:
+        return
+
     # Apply trading logic
     valid_quotes = quotes_df[
         (quotes_df['lastPrice'] >= 0.005) &
@@ -116,8 +122,8 @@ def sell_the_algo_buys(orders_api, account_hash, quotes_api):
 
 def check_cash_account(account_api, account_hash):
     account = account_api.get_account(account_hash=account_hash, fields="positions")
-    print(account)
-    cash_account = account['cash']
+    # print(account)
+    cash_account = account["securitiesAccount"]["type"] == "CASH"
     return cash_account
 
 
@@ -147,4 +153,4 @@ def main():
     find_trades_from_quotes(orders_api, quotes, account_hash)
 
     # Sell trades
-    sell_the_algo_buys(orders_api, account_hash, quotes_api)
+    sell_the_algo_buys(orders_api, account_hash, quotes_api)

pythonic_schwab_api/api_client.py

@@ -1,4 +1,5 @@
 import random
+import re
 from time import sleep
 import requests
 import webbrowser
@@ -85,7 +86,7 @@ def refresh_access_token(self):
         }
         if not self.post_token_request(data):
             self.logger.error("Failed to refresh access token.")
-            return False
+            self.manual_authorization_flow()
         self.token_info = self.load_token()
         return self.validate_token()
 
@@ -119,7 +120,8 @@ def validate_token(self, force=False):
             print("Token expired or invalid.")
             # get AAPL to validate token
             params = {'symbol': 'AAPL'}
-            response = self.make_request(endpoint=f"{self.config.MARKET_DATA_BASE_URL}/chains", params=params, validating=True)
+            response = self.make_request(endpoint=f"{self.config.MARKET_DATA_BASE_URL}/chains", params=params,
+                                         validating=True)
             print(response)
             if response:
                 self.logger.info("Token validated successfully.")
@@ -129,34 +131,81 @@ def validate_token(self, force=False):
         return False
 
     def make_request(self, endpoint, method="GET", **kwargs):
+        """
+        Make authenticated HTTP requests.
+
+        Args:
+            endpoint (str): The API endpoint.
+            method (str, optional): The HTTP method. Defaults to "GET".
+            **kwargs: Additional parameters for the request.
+
+        Returns:
+            dict: The JSON response from the API if available, else None.
+
+        Raises:
+            HTTPError: If the request fails.
+        """
+        # Introduce a random delay to avoid hitting the server too quickly
         sleep(0.5 + random.randint(0, 1000) / 1000)
-        """ Make authenticated HTTP requests. """
+
+        # Validate the token if not in a validation process
         if 'validating' not in kwargs:
             if not self.validate_token():
                 self.logger.info("Token expired or invalid, re-authenticating.")
-                self.manual_authorization_flow()
+                self.refresh_access_token()
         kwargs.pop('validating', None)
+
+        # Construct the full URL if the base URL is not included
         if self.config.API_BASE_URL not in endpoint:
             url = f"{self.config.API_BASE_URL}{endpoint}"
         else:
             url = endpoint
-        print(f"Making request to {url} with method {method} and kwargs {kwargs} (validating already popped if present)")
+
+        self.logger.debug(f"Making request to {url} with method {method} and kwargs {kwargs}")
+
+        # Set the authorization headers
         headers = {'Authorization': f"Bearer {self.token_info['access_token']}"}
+
+        # Make the HTTP request
         response = self.session.request(method, url, headers=headers, **kwargs)
-        print(response.status_code)
-        print(response.text)
+
+        # Handle token expiration during the request
         if response.status_code == 401:
             self.logger.warning("Token expired during request. Refreshing token...")
-            self.manual_authorization_flow()
+            self.refresh_access_token()
             headers = {'Authorization': f"Bearer {self.token_info['access_token']}"}
             response = self.session.request(method, url, headers=headers, **kwargs)
+
+        # Log for non-200 responses
+        if response.status_code != 200:
+            order_pattern = r"https://api\.schwabapi\.com/trader/v1/accounts/.*/orders"
+            if response.status_code == 201 and re.match(order_pattern, url):
+                location = response.headers.get('location')
+                if location:
+                    order_id = location.split('/')[-1]
+                    self.logger.debug(f"Order placed successfully. Order ID: {order_id}")
+                    return {"order_id": order_id, "success": True}
+                else:
+                    self.logger.error("201 response without a location header.")
+                    return None
+
         response.raise_for_status()
-        return response.json()
+
+        # Check if response content is empty before parsing as JSON
+        if response.content:
+            try:
+                return response.json()
+            except json.JSONDecodeError as e:
+                self.logger.error(f"Error decoding JSON response: {e}")
+                raise requests.exceptions.JSONDecodeError(e.msg, e.doc, e.pos)
+        else:
+            self.logger.debug("Empty response content")
+            return None
 
     def get_user_preferences(self):
         """Retrieve user preferences."""
         try:
             return self.make_request(f'{self.config.TRADER_BASE_URL}/userPreference')
         except Exception as e:
             self.logger.error(f"Failed to get user preferences: {e}")
-            return None
+            return None

pythonic_schwab_api/market_data.py

@@ -1,3 +1,6 @@
+import urllib.parse as urll
+
+
 class Quotes:
     def __init__(self, client):
         self.client = client
@@ -13,6 +16,8 @@ def get_list(self, symbols=None, fields=None, indicative=False):
 
     def get_single(self, symbol_id, fields=None):
         params = {'fields': fields}
+        if urll.unquote(symbol_id) == symbol_id:
+            symbol_id = urll.quote(symbol_id)
         return self.client.make_request(f"{self.base_url}/{symbol_id}/quotes", params=params)
 
 
@@ -70,4 +75,4 @@ def by_symbol(self, symbol, projection):
         return self.client.make_request(self.base_url, params=params)
 
     def by_cusip(self, cusip_id):
-        return self.client.make_request(f"{self.base_url}/{cusip_id}")
+        return self.client.make_request(f"{self.base_url}/{cusip_id}")

pythonic_schwab_api/orders.py

@@ -6,6 +6,30 @@ def __init__(self, client):
         self.client = client
         self.base_url = client.config.ORDERS_BASE_URL
 
+    def create_order_schema(self, symbol, side, quantity, order_type='MARKET', limit_price=None, time_in_force='DAY', session='NORMAL'):
+        """Create a new order schema."""
+        if order_type not in ['MARKET']:
+            quantity = int(quantity)
+        order = {
+            'orderType': order_type,
+            'session': session,
+            'duration': time_in_force,
+            'orderStrategyType': 'SINGLE',
+            'orderLegCollection': [
+                {
+                    'instruction': side,
+                    'quantity': quantity,
+                    'instrument': {
+                        'symbol': symbol,
+                        'assetType': 'EQUITY'
+                    }
+                }
+            ]
+        }
+        if order_type == 'LIMIT':
+            order['price'] = limit_price
+        return order
+
     def get_orders(self, account_hash, max_results=100, from_entered_time=None, to_entered_time=None, status=None):
         """Retrieve a list of orders for a specified account."""
         if from_entered_time is None:
@@ -21,10 +45,18 @@ def get_orders(self, account_hash, max_results=100, from_entered_time=None, to_e
         endpoint = f"{self.base_url}/{account_hash}/orders"
         return self.client.make_request(endpoint, params=params)
 
+    def preview_order(self, account_hash, order_details):
+        """Preview a new order for an account."""
+        # TODO: Coming Soon per the API documentation
+        return "test"
+        endpoint = f"{self.base_url}/{account_hash}/orders/previewOrder"
+        return self.client.make_request(method="POST", endpoint=endpoint, data=order_details)
+
     def place_order(self, account_hash, order_details):
         """Place a new order for an account."""
         endpoint = f"{self.base_url}/{account_hash}/orders"
-        return self.client.post(endpoint, data=order_details)
+        filtered_order_details = {k: v for k, v in order_details.items() if v is not None}
+        return self.client.make_request(method="POST", endpoint=endpoint, json=filtered_order_details)
 
     def get_order(self, account_hash, order_id):
         """Retrieve details for a specific order."""
@@ -39,4 +71,4 @@ def cancel_order(self, account_hash, order_id):
     def replace_order(self, account_hash, order_id, new_order_details):
         """Replace an existing order with new details."""
         endpoint = f"{self.base_url}/{account_hash}/orders/{order_id}"
-        return self.client.make_request(endpoint, method='PUT', data=new_order_details)
+        return self.client.make_request(endpoint, method='PUT', data=new_order_details)