Merge pull request #2 from Patch-Code-Prosperity/Cfomodz-refactor-1

Cfomodz · web-flow · commit 8938576ac864 · 2024-05-12T19:55:52.000-04:00
Cfomodz refactor 1 - This PR Completes the initial overhaul and begins trying to get a stable main branch so we can start working on the fun stuff!
diff --git a/accounts.py b/accounts.py
@@ -0,0 +1,54 @@
+from config import TRADER_BASE_URL
+import logging
+
+class Accounts:
+    def __init__(self, client):
+        self.client = client
+        self.logger = logging.getLogger(__name__)
+        self.base_url = TRADER_BASE_URL
+
+    def get_account_numbers(self):
+        """Retrieve account numbers associated with the user's profile."""
+        try:
+            return self.client.get(f'{self.base_url}/accountNumbers')
+        except Exception as e:
+            self.logger.error(f"Failed to get account numbers: {e}")
+            return None
+
+    def get_all_accounts(self, fields=None):
+        """Retrieve detailed information for all linked accounts, optionally filtering the fields."""
+        params = {'fields': fields} if fields else {}
+        try:
+            return self.client.get(f'{self.base_url}', params=params)
+        except Exception as e:
+            self.logger.error(f"Failed to get all accounts: {e}")
+            return None
+
+    def get_account(self, account_hash, fields=None):
+        """Retrieve detailed information for a specific account using its hash."""
+        if not account_hash:
+            self.logger.error("Account hash is required for getting account details")
+            return None
+        params = {'fields': fields} if fields else {}
+        try:
+            return self.client.get(f'{self.base_url}/{account_hash}', params=params)
+        except Exception as e:
+            self.logger.error(f"Failed to get account {account_hash}: {e}")
+            return None
+
+    def get_account_transactions(self, account_hash, start_date, end_date, types=None, symbol=None):
+        """Retrieve transactions for a specific account over a specified date range."""
+        if not (isinstance(start_date, datetime.datetime) and isinstance(end_date, datetime.datetime)):
+            self.logger.error("Invalid date format. Dates must be datetime objects")
+            return None
+        params = {
+            'startDate': start_date.isoformat(),
+            'endDate': end_date.isoformat(),
+            'types': types,
+            'symbol': symbol
+        }
+        try:
+            return self.client.get(f'{self.base_url}/{account_hash}/transactions', params=params)
+        except Exception as e:
+            self.logger.error(f"Failed to get transactions for account {account_hash}: {e}")
+            return None
diff --git a/api_client.py b/api_client.py
@@ -0,0 +1,66 @@
+import requests
+import logging
+import json
+from datetime import datetime, timedelta
+from config import APIConfig
+
+class APIClient:
+    def __init__(self):
+        self.session = requests.Session()
+        self.setup_logging()
+
+        if not self.validate_credentials():
+            logging.error("Invalid or missing credentials. Please check your configuration.")
+            exit(1)
+        
+        self.token_info = self.load_token() or self.authenticate()
+
+    def setup_logging(self):
+        logging.basicConfig(**APIConfig.LOGGING_CONFIG)
+        self.logger = logging.getLogger(__name__)
+
+    def validate_credentials(self):
+        return all([APIConfig.APP_KEY, APIConfig.APP_SECRET, APIConfig.CALLBACK_URL])
+
+    def authenticate(self):
+        """Authenticate with the API and store the new token information."""
+        data = {
+            'grant_type': 'client_credentials',
+            'client_id': APIConfig.APP_KEY,
+            'client_secret': APIConfig.APP_SECRET
+        }
+        response = self.session.post(f"{APIConfig.API_BASE_URL}/v1/oauth/token", data=data)
+        response.raise_for_status()
+        token_data = response.json()
+        self.save_token(token_data)
+        return token_data
+
+    def save_token(self, token_data):
+        """Saves the token data securely to a file."""
+        token_data['expires_at'] = (datetime.now() + timedelta(seconds=token_data['expires_in'])).isoformat()
+        with open('token_data.json', 'w') as f:
+            json.dump(token_data, f)
+        self.logger.info("Token data saved successfully.")
+
+    def load_token(self):
+        """Loads the token data from a file if it is still valid."""
+        try:
+            with open('token_data.json', 'r') as f:
+                token_data = json.load(f)
+                if datetime.now() < datetime.fromisoformat(token_data['expires_at']):
+                    self.logger.info("Token loaded successfully from file.")
+                    return token_data
+        except (FileNotFoundError, KeyError, ValueError) as e:
+            self.logger.warning(f"Loading token failed: {e}")
+        return None
+
+    def make_request(self, method, endpoint, **kwargs):
+        """Makes an HTTP request using the authenticated session."""
+        url = f"{APIConfig.API_BASE_URL}{endpoint}"
+        response = self.session.request(method, url, **kwargs)
+        if response.status_code == 401:  # Token expired
+            self.logger.warning("Token expired. Refreshing token...")
+            self.token_info = self.authenticate()
+            response = self.session.request(method, url, **kwargs)
+        response.raise_for_status()
+        return response.json()
diff --git a/api_utilities.py b/api_utilities.py
@@ -0,0 +1,57 @@
+import datetime
+
+class ParameterParser:
+    @staticmethod
+    def clean_params(params):
+        """
+        Removes None values from a dictionary of parameters.
+        This ensures that only valid parameters are sent in API requests.
+        
+        Parameters:
+            params (dict): A dictionary containing parameter names and values.
+        
+        Returns:
+            dict: A dictionary with all None values removed.
+        """
+        return {k: v for k, v in params.items() if v is not None}
+
+class DateTimeConverter:
+    @staticmethod
+    def convert_time(dt=None, format_type="8601"):
+        """
+        Converts datetime objects into a string format according to a specified format type.
+        Supports ISO 8601, epoch time in milliseconds, and custom date formats.
+
+        Parameters:
+            dt (datetime.datetime, optional): The datetime object to convert. Defaults to None.
+            format_type (str, optional): The type of format to convert the datetime into. 
+                Supported types are "8601" for ISO8601 format, "epoch" for epoch time in milliseconds, 
+                and "YYYY-MM-DD" for custom date format. Defaults to "8601".
+
+        Returns:
+            str or int: The formatted date string or integer (for epoch), or None if dt is None.
+        """
+        if dt is None:
+            return None
+
+        formats = {
+            "8601": lambda x: x.isoformat()[:-3] + 'Z',  # Reduces to milliseconds and appends 'Z' to denote UTC time
+            "epoch": lambda x: int(x.timestamp() * 1000),  # Converts to milliseconds since the Unix epoch
+            "YYYY-MM-DD": lambda x: x.strftime("%Y-%m-%d")  # Formats date as YYYY-MM-DD
+        }
+        return formats.get(format_type, lambda x: x)(dt)
+
+def format_list(items):
+    """
+    Converts a list of items into a comma-separated string. If the input is not a list, it returns the input as is.
+    This is used to format lists for parameters in API requests where multiple values can be passed as comma-separated.
+
+    Parameters:
+        items (list or str): A list of items or a single string item.
+
+    Returns:
+        str: A comma-separated string if items is a list, otherwise the original input string.
+    """
+    if items is None:
+        return None
+    return ",".join(items) if isinstance(items, list) else items
diff --git a/config.py b/config.py
@@ -0,0 +1,24 @@
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+class APIConfig:
+    API_BASE_URL = "https://api.schwabapi.com"
+    TRADER_BASE_URL = f"{API_BASE_URL}/trader/v1"
+    MARKET_DATA_BASE_URL = f"{API_BASE_URL}/marketdata/v1"
+    ORDER_BASE_URL = f"{API_BASE_URL}/accounts"
+    REQUEST_TIMEOUT = 30  # Timeout for API requests in seconds
+    RETRY_STRATEGY = {
+        'total': 3,         # Total number of retries to allow
+        'backoff_factor': 1 # Factor by which the delay between retries will increase
+    }
+    TOKEN_REFRESH_THRESHOLD_SECONDS = 300  # Time in seconds before token expiration to attempt refresh
+    DEBUG_MODE = False
+    LOGGING_CONFIG = {
+        'level': 'INFO',
+        'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    }
+    APP_KEY = os.getenv('APP_KEY')
+    APP_SECRET = os.getenv('APP_SECRET')
+    CALLBACK_URL = os.getenv('CALLBACK_URL')
diff --git a/main.py b/main.py
@@ -1,22 +1,30 @@
-from modules import api, stream
 from datetime import datetime, timedelta
+from api_client import APIClient
+from accounts import Accounts
+from orders import Orders
+from market_data import MarketData
 
 def main():
+    client = APIClient()  # Initialize the API client
+    accounts_api = Accounts(client)
+    orders_api = Orders(client)
+    market_data_api = MarketData(client)
+
     # Get account numbers for linked accounts
-    print(api.accounts.get_account_numbers().json())
+    print(accounts_api.get_account_numbers().json())
 
     # Get positions for linked accounts
-    print(api.accounts.get_all_accounts().json())
+    print(accounts_api.get_all_accounts().json())
 
     # Get specific account positions
-    print(api.accounts.get_account(fields="positions").json())
+    print(accounts_api.get_account(fields="positions").json())
 
     # Get up to 3000 orders for an account for the past week
-    print(api.orders.get_orders(3000, datetime.now() - timedelta(days=7), datetime.now()).json())
+    print(orders_api.get_orders(3000, datetime.now() - timedelta(days=7), datetime.now()).json())
 
-    # Place an order (uncomment to test)
+    # Example to place an order (commented out for safety)
     """
-    order = {
+    order_details = {
         "orderType": "LIMIT", 
         "session": "NORMAL", 
         "duration": "DAY", 
@@ -26,64 +34,55 @@ def main():
             {"instruction": "BUY", "quantity": 1, "instrument": {"symbol": "INTC", "assetType": "EQUITY"}}
         ]
     }
-    response = api.orders.place_order(order)
-    print(f"Place order response: {response}")
-    order_id = response.headers.get('location', '/').split('/')[-1]
-    print(f"OrderID: {order_id}")
-
-    # Get a specific order
-    print(api.orders.get_order(order_id).json())
-
-    # Cancel specific order
-    print(api.orders.cancel_order(order_id))
+    order_response = orders_api.place_order('account_hash', order_details)
+    print(f"Place order response: {order_response.json()}")
+    order_id = order_response.headers.get('location', '/').split('/')[-1]
     """
 
-    # Replace specific order
-    # api.orders.replace_order(order_id, order)
+    # Get a specific order
+    # print(orders_api.get_order('account_hash', order_id).json())
 
     # Get up to 3000 orders for all accounts for the past week
-    print(api.orders.get_all_orders(3000, datetime.now() - timedelta(days=7), datetime.now()).json())
+    print(orders_api.get_orders(3000, datetime.now() - timedelta(days=7), datetime.now()).json())
 
     # Get all transactions for an account
-    print(api.transactions.get_transactions(datetime.now() - timedelta(days=7), datetime.now(), "TRADE").json())
+    print(accounts_api.get_account_transactions('account_hash', datetime.now() - timedelta(days=7), datetime.now(), "TRADE").json())
 
     # Get user preferences for an account
-    print(api.user_preference.get_user_preference().json())
+    print(accounts_api.get_user_preferences('account_hash').json())
+
+    # Market-data-related requests
+    quotes = market_data_api.Quotes(market_data_api)
+    options = market_data_api.Options(market_data_api)
+    price_history = market_data_api.PriceHistory(market_data_api)
+    movers = market_data_api.Movers(market_data_api)
+    market_hours = market_data_api.MarketHours(market_data_api)
+    instruments = market_data_api.Instruments(market_data_api)
 
     # Get a list of quotes
-    print(api.quotes.get_list(["AAPL", "AMD"]).json())
+    print(quotes.get_list(["AAPL", "AMD"]).json())
 
     # Get a single quote
-    print(api.quotes.get_single("INTC").json())
+    print(quotes.get_single("INTC").json())
 
     # Get an option expiration chain
-    print(api.options.get_expiration_chain("AAPL").json())
+    print(options.get_chains("AAPL").json())
 
     # Get movers for an index
-    print(api.movers.get_movers("$DJI").json())
+    print(movers.get_movers("$DJI").json())
 
     # Get market hours for symbols
-    print(api.market_hours.get_by_markets("equity,option").json())
+    print(market_hours.by_markets("equity,option").json())
 
     # Get market hours for a market
-    print(api.market_hours.get_by_market("equity").json())
+    print(market_hours.by_market("equity").json())
 
     # Get instruments for a symbol
-    print(api.instruments.get_by_symbol("AAPL", "search").json())
+    print(instruments.by_symbol("AAPL", "search").json())
 
     # Get instruments for a CUSIP
-    print(api.instruments.get_by_cusip("037833100").json())  # 037833100 = AAPL
-
-    # Send a subscription request to the stream (uncomment if you start the stream below)
-    """
-    stream.send(stream.utilities.basic_request("CHART_EQUITY", "SUBS", parameters={"keys": "AMD,INTC", "fields": "0,1,2,3,4,5,6,7,8"}))
-    # Stop the stream after 30s
-    stream.stop()
-    """
+    print(instruments.by_cusip("037833100").json())  # 037833100 = AAPL
 
 if __name__ == '__main__':
-    print("Welcome to the unofficial Schwab API interface!\nGitHub: https://github.com/tylerebowers/Schwab-API-Python")
-    api.initialize()  # checks tokens & loads variables
-    api.update_tokens_automatically()  # starts thread to update tokens automatically
-    # stream.start_manual()  # start the stream manually
-    main()  # call the user code above
+    print("Welcome to the unofficial Schwab API interface!\nGitHub: https://github.com/Patch-Code-Prosperity/Pythonic-Schwab-API")
+    main()
diff --git a/market_data.py b/market_data.py
diff --git a/orders.py b/orders.py
