woim-Copy1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "26c8ec99",
   "metadata": {},
   "outputs": [],
   "source": [
    "# https://www.smbtraining.com/member/weekly-options-income-machine/calendar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "60c5c1dd",
   "metadata": {},
   "outputs": [],
   "source": [
    "from selenium import webdriver\n",
    "from selenium.common.exceptions import NoSuchWindowException,WebDriverException,StaleElementReferenceException,NoSuchElementException\n",
    "import datetime\n",
    "import time as tm\n",
    "import json\n",
    "import pickle\n",
    "import pprint\n",
    "from td.client import TDClient\n",
    "from td.exceptions import NotFndError,NotNulError\n",
    "import traceback\n",
    "\n",
    "\n",
    "with open('/home/cc/tdcred.json',\"r\") as read_file:\n",
    "    cred = json.load(read_file)\n",
    "\n",
    "\n",
    "COOKIE_PATH = \"/home/cc/chrome-cookies.pkl\"\n",
    "\n",
    "TEST_PATH = None\n",
    "TEST_STRIKE = None\n",
    "TEST_PRICE = None\n",
    "\n",
    "#TEST_PATH = 'file:///home/cc/options/process/python/MasterTrader/sample_page2/The%20Weekly%20Options%20Income%20Machine%20Program%20_%20Trader%20Training%20courses-SMB%20Capital-Stocks%20Options%20Trading%20tools.html'\n",
    "#TEST_STRIKE = 4195\n",
    "#TEST_PRICE = 10.00\n",
    "\n",
    "STRIKE_SPREAD = 15\n",
    "QUANTITY = 1\n",
    "\n",
    "TRADE_SYMBOL = '$SPX.X'\n",
    "\n",
    "MODIFY_ORDER_TRIES = 5\n",
    "MODIFY_WAIT_TIME = 15\n",
    "\n",
    "MAX_ORDERS = 3\n",
    "\n",
    "MONITOR_TIME_START = datetime.time(6,10)\n",
    "MONITOR_TIME_END = datetime.time(6,40)\n",
    "#MONITOR_TIME_END = datetime.time(14,25)\n",
    "\n",
    "\n",
    "with open('/home/cc/woim',\"r\") as read_file:\n",
    "    info = json.load(read_file)\n",
    "    \n",
    "    \n",
    "if TEST_PATH is not None:\n",
    "    info['url'] = TEST_PATH\n",
    "    \n",
    "    \n",
    "    \n",
    "# cookie_login was used when cookies are loaded from already logged in session\n",
    "# use manual log in now\n",
    " \n",
    "def cookie_login_page(driver,info):\n",
    "\n",
    "    driver.get(info['url1'])\n",
    "    \n",
    "    if TEST_PATH is not None:\n",
    "        return\n",
    "\n",
    "\n",
    "    cookies = pickle.load(open(COOKIE_PATH,\"rb\"))\n",
    "    for cookie in cookies:\n",
    "        driver.add_cookie(cookie)\n",
    "    \n",
    "    driver.get(info['url2'])\n",
    "\n",
    "    \n",
    "#info = { 'url': '/home/cc/Dropbox/sample_page/The Weekly Options Income Machine Program _ Trader Training courses-SMB Capital-Stocks Options Trading tools.html'}\n",
    "#info = { 'url': 'sample_page/The Weekly Options Income Machine Program _ Trader Training courses-SMB Capital-Stocks Options Trading tools.html'}\n",
    "\n",
    "  \n",
    "#driver.get(\"https://google.co.in\")\n",
    "\n",
    "#need to load the page, in order to set the log in cookies, then load page again\n",
    "\n",
    "def wait_for_element(func,id,tries):\n",
    "    while True:\n",
    "        try:\n",
    "            form = func(id)\n",
    "            return form\n",
    "        \n",
    "        except NoSuchElementException as e:\n",
    "            tries -= 1\n",
    "            if not tries:\n",
    "                raise e\n",
    "            tm.sleep(.1)\n",
    "    \n",
    "\n",
    "def manual_login(driver,cred):\n",
    "\n",
    "    driver.get(cred['url1'])\n",
    "    log_in = driver.find_element_by_xpath(\"// a[contains(text(),'Login')]\")\n",
    "    log_in.click()\n",
    "    \n",
    "    form = wait_for_element(driver.find_element_by_id,'user-login',10)\n",
    "\n",
    "\n",
    "    edit_name = form.find_element_by_id(\"edit-name\")\n",
    "    edit_pass = form.find_element_by_id(\"edit-pass\")\n",
    "    edit_submit = form.find_element_by_id(\"edit-submit\")\n",
    "    edit_name.send_keys(cred['user'])\n",
    "    edit_pass.send_keys(cred['pwd'])\n",
    "    edit_submit.click()\n",
    "    \n",
    "    log_in = wait_for_element(driver.find_element_by_xpath,\"// a[contains(text(),'Member Area')]\",120)\n",
    "    \n",
    "    driver.get(cred['url2'])\n",
    "\n",
    "\n",
    "\n",
    "    \n",
    "def find_option_lowest_dte(session,symbol,spread_type,strike,date_today):\n",
    "    \n",
    "    print(\"find_option_lowest_dte: symbol= {} spread_type = {} strike = {} date_today = {}\".format(symbol,spread_type,strike,date_today))\n",
    "    \n",
    "    spread_type = spread_type.upper()\n",
    "    \n",
    "    opt_chain = {\n",
    "    'symbol': symbol,\n",
    "    #'contractType': spread_type,\n",
    "    'optionType': 'S',\n",
    "    'fromDate': date_today.strftime('%Y-%m-%d'),\n",
    "    'afterDate': date_today.strftime(\"%Y-%m-%d\"),\n",
    "    'includeQuotes': True,\n",
    "    'strike' : strike\n",
    "    }\n",
    "    \n",
    "    maptype = {'PUT': 'putExpDateMap',\n",
    "              'CALL': 'callExpDateMap'}\n",
    "    \n",
    "    option_chains = session.get_options_chain(option_chain=opt_chain)\n",
    "    \n",
    "    #print(len(option_chains))\n",
    "    #return option_chains\n",
    "    \n",
    "    putcallExpDateMap = option_chains[maptype[spread_type]]\n",
    "    \n",
    "    lowest_dte = None\n",
    "    lowest_key = None\n",
    "    for key in putcallExpDateMap.keys():\n",
    "        days_to_expire = int(key.split(':')[1])\n",
    "        if lowest_dte is None or (days_to_expire >= 0 and days_to_expire < lowest_dte):\n",
    "            lowest_dte = days_to_expire\n",
    "            lowest_key = key\n",
    "            \n",
    "    print(\"lowest dte date:\",lowest_key,lowest_dte)\n",
    "            \n",
    "    key = lowest_key\n",
    "\n",
    "    key_date = lowest_key\n",
    "    days_to_expire = lowest_dte\n",
    "        \n",
    "    #d = datetime.datetime.strptime(key_date,'%Y-%m-%d').date()\n",
    "    #print('exp-date',key,key_date,d,expiration)\n",
    "    #if d == expiration:\n",
    "            #print(\"found one\")\n",
    "            \n",
    "    info = putcallExpDateMap[key]\n",
    "            \n",
    "            #print('a')\n",
    "            #print(info)\n",
    "            \n",
    "    for strike_entry in info.keys():\n",
    "                \n",
    "        if (float(strike_entry) == float(strike)):\n",
    "            for entry in info[strike_entry]:\n",
    "                if '(PM)' in entry['description']:\n",
    "                    return entry\n",
    "                    \n",
    "                \n",
    "    return None\n",
    "\n",
    "def get_leg_info(session,underlying_symbol,strike_type,sell_strike,buy_strike,date_today):\n",
    "    sell_info = find_option_lowest_dte(session,underlying_symbol,strike_type,sell_strike,date_today)\n",
    "    buy_info = find_option_lowest_dte(session,underlying_symbol,strike_type,buy_strike,date_today)\n",
    "    \n",
    "    return sell_info,buy_info\n",
    "\n",
    "\n",
    "def create_order_payload(session,underlying_symbol,quantity,strike_type,sell_strike,buy_strike,date_today,mid_offset = 0):\n",
    "    \n",
    "    sell_info,buy_info = get_leg_info(session,underlying_symbol,strike_type,sell_strike,buy_strike,date_today)\n",
    "    \n",
    "    #print(\"sell_info\")\n",
    "    #pprint.pprint(sell_info)\n",
    "    if sell_info is None:\n",
    "        return None\n",
    "    \n",
    "    #print(\"buy_info\")\n",
    "    #pprint.pprint(buy_info)\n",
    "    if buy_info is None:\n",
    "        return None\n",
    "    \n",
    "    mid_price = (sell_info['ask'] + sell_info['bid'])/2 - (buy_info['ask'] + buy_info['bid'])/2\n",
    "    \n",
    "    mid_price = round(mid_price,2)\n",
    "    \n",
    "    print(\"initial mid price is: \",mid_price)\n",
    "    \n",
    "    if TEST_PRICE is not None:\n",
    "        mid_price = TEST_PRICE  #set a high price for now and adjust in TOS\n",
    "        \n",
    "    mid_price = mid_price + mid_offset\n",
    "    \n",
    "    mid_price = round(mid_price,2)\n",
    "        \n",
    "    print(\"using price:\",mid_price)\n",
    "    \n",
    "    \n",
    "    sell_limit_vertical_spread = {\n",
    "        \"session\": \"NORMAL\",\n",
    "        \"duration\": \"DAY\",\n",
    "        \"orderType\": \"NET_CREDIT\",  #NET_DEBIT highest price to buy  NET_CREDIT highest price to sell.  (CC Note: I think should be lowest price to sell)\n",
    "        \"orderStrategyType\": \"SINGLE\",\n",
    "        \"complexOrderStrategyType\": \"VERTICAL\",\n",
    "        \"price\": mid_price,\n",
    "        \"orderLegCollection\": [\n",
    "            {\n",
    "                \"orderLegType\": \"OPTION\",\n",
    "                \"instrument\": {\n",
    "                    \"symbol\": sell_info['symbol'],\n",
    "                    \"assetType\": \"OPTION\"\n",
    "                },\n",
    "                \"instruction\": \"SELL_TO_OPEN\",\n",
    "                \"quantity\": quantity\n",
    "            },\n",
    "            {\n",
    "                \"orderLegType\": \"OPTION\",\n",
    "                \"instrument\": {\n",
    "                    \"symbol\": buy_info['symbol'],\n",
    "                    \"assetType\": \"OPTION\"\n",
    "                },\n",
    "                \"instruction\": \"BUY_TO_OPEN\",\n",
    "                \"quantity\": quantity\n",
    "            }\n",
    "        ]\n",
    "    }\n",
    "    \n",
    "    return sell_limit_vertical_spread\n",
    "\n",
    "class MaxOrdersReachedError(Exception):\n",
    "    pass\n",
    "\n",
    "\n",
    "def cancel_trade(session,responce_dict):\n",
    "        try:\n",
    "            cancel_response = session.cancel_order(cred['accountID'], response_dict['order_id'])\n",
    "        except NotFndError:\n",
    "            print(\"could not find while canceling\",response_dict['order_id'])\n",
    "            return False\n",
    "        \n",
    "        print(\"cancel response is:\")\n",
    "        pprint.pprint(cancel_response)\n",
    "        \n",
    "        #orders = session.get_orders_query(cred['accountID'])\n",
    "        \n",
    "        while True:\n",
    "            print(\"searching for canceled order\")\n",
    "            \n",
    "            try:\n",
    "                order = session.get_orders(cred['accountID'], response_dict['order_id'])\n",
    "            except NotFndError:\n",
    "                print('could not find canceled order: ',response_dict['order_id'])\n",
    "                return False\n",
    "            \n",
    "            if order['status'] == 'FILLED':\n",
    "                print(\"order has been filled:\",response_dict['order_id'])\n",
    "                return False\n",
    "            \n",
    "            if order['status'] == 'CANCELED':\n",
    "                break\n",
    "                \n",
    "            tm.sleep(.5)\n",
    "\n",
    "                \n",
    "        print(\"found order: \",order['orderId'])\n",
    "        pprint.pprint(order)\n",
    "        print(\"found order end\")\n",
    "        \n",
    "        print(\"Order status is now: \",order['status'])\n",
    "        \n",
    "        return order\n",
    "\n",
    "\n",
    "def manage_trade(session,order_dict,strike_type,sell_strike,buy_strike,mid_offset):\n",
    "    global global_price\n",
    "    \n",
    "    quantity = order_dict['quantity']\n",
    "    \n",
    "    try_limit = MODIFY_ORDER_TRIES\n",
    "    \n",
    "    while(True):\n",
    "        \n",
    "        \n",
    "        print(\"try num:\",try_limit)\n",
    "        \n",
    "        \n",
    "        try:\n",
    "            response_dict = session.place_order(cred['accountID'],order_dict)\n",
    "            print(\"response to new order\")\n",
    "            pprint.pprint(response_dict)\n",
    "            order_accepted = True\n",
    "\n",
    "        except NotNullError:\n",
    "            print(\"manage_trade NotNullError:\")\n",
    "            traceback.print_exc()\n",
    "            order_accepted = False\n",
    "        except:\n",
    "            print( \"manage_trade unexpected error:\")\n",
    "            traceback.print_exc()\n",
    "            raise\n",
    "            \n",
    "            \n",
    "        if order_accepted:\n",
    "            tm.sleep(MODIFY_WAIT_TIME)\n",
    "            \n",
    "            cancel_response = cancel_trade(session,response_dict)\n",
    "                \n",
    "            if cancel_response is False:\n",
    "                return\n",
    "            \n",
    "            order = cancel_response\n",
    "            quantity = order['quantity'] - order['filledQuantity']\n",
    "\n",
    "            try_limit = try_limit - 1\n",
    "                    \n",
    "        \n",
    "        if try_limit<0:\n",
    "            print(\"manage_trade, exceeded tries\")\n",
    "            return\n",
    "        \n",
    "        sell_info,buy_info = get_leg_info(session,'$SPX.X',strike_type,sell_strike,buy_strike,datetime.date.today())\n",
    "                    \n",
    "        lowest_price = sell_info['bid'] - buy_info['ask']\n",
    "                    \n",
    "        mid_price = (sell_info['ask'] + sell_info['bid'])/2 - (buy_info['ask'] + buy_info['bid'])/2\n",
    "        mid_price = round(mid_price,2)\n",
    "                    \n",
    "        print(\"natural mid price: \",mid_price, sell_info['ask'],sell_info['bid'],buy_info['ask'],buy_info['bid'])\n",
    "        print(\"natural lowest price: \",lowest_price)\n",
    "                    \n",
    "        #mid_price = global_price\n",
    "                    \n",
    "        mid_price +=  mid_offset\n",
    "                    \n",
    "        if mid_price > lowest_price:                \n",
    "            mid_offset -= .05\n",
    "        else:\n",
    "            mid_price = lowest_price\n",
    "                        \n",
    "        order_dict['price'] = round(mid_price,2)\n",
    "        order_dict['quantity'] = quantity\n",
    "                    \n",
    "        print(\"new order price and limit\",mid_price,lowest_price)\n",
    "        \n",
    "\n",
    "                                                                \n",
    "def get_TDSession():\n",
    "    \n",
    "    TDSession = TDClient(\n",
    "        account_number=cred['accountID'],\n",
    "        client_id = cred['client_id'],\n",
    "        credentials_path = '/home/cc/Credentials/td_state.json',\n",
    "        redirect_uri = \"https://127.0.0.1\"\n",
    "    )\n",
    "\n",
    "    TDSession.login()\n",
    "    \n",
    "    return TDSession\n",
    "\n",
    "def test_td():\n",
    "    TDSession = get_TDSession()\n",
    "    \n",
    "    msft_quotes = TDSession.get_quotes(instruments=['MSFT'])\n",
    "    \n",
    "    pprint.pprint(msft_quotes)\n",
    "\n",
    "def execute_trade(option_info):\n",
    "    \n",
    "    \n",
    "    TDSession = get_TDSession()\n",
    "    \n",
    "    strike_type = 'put' if option_info['put'] else 'call'\n",
    "    \n",
    "    sell_strike = option_info['strike']\n",
    "    if TEST_STRIKE is not None:\n",
    "        sell_strike = TEST_STRIKE\n",
    "\n",
    "    buy_strike = sell_strike + (-STRIKE_SPREAD if option_info['put'] else STRIKE_SPREAD)\n",
    "        \n",
    "    mid_offset = 0\n",
    "        \n",
    "    order_dict = create_order_payload(TDSession,TRADE_SYMBOL,QUANTITY,strike_type,sell_strike,buy_strike,datetime.datetime.now().date(),mid_offset)\n",
    "\n",
    "    \n",
    "    manage_trade(TDSession,order_dict,strike_type,sell_strike,buy_strike,mid_offset)\n",
    "    \n",
    "\n",
    "\n",
    "def process_alerts(alert_texts):\n",
    "    \n",
    "    option_info = {\n",
    "        'bullish':  None,\n",
    "        'put' : None,\n",
    "        'strike' : None\n",
    "    }\n",
    "    \n",
    "    for alert in alert_texts:\n",
    "        alert = alert.lower()\n",
    "        \n",
    "        if 'final' in alert: # this is todays final message\n",
    "            \n",
    "            print(\"final message\")\n",
    "            return False\n",
    "        \n",
    "        if 'chance' in alert:\n",
    "            \n",
    "            if 'bullish' in alert:\n",
    "                option_info['bullish'] = True\n",
    "                \n",
    "            if 'bearish' in alert:\n",
    "                option_info['bullish'] = False\n",
    "                \n",
    "        if 'suggesting' in alert:\n",
    "            \n",
    "            if 'put' in alert:\n",
    "                option_info['put'] = True\n",
    "            if 'call' in alert:\n",
    "                option_info['put'] = False\n",
    "            \n",
    "            for word in alert.split():\n",
    "                \n",
    "                word = word.strip(',:.')\n",
    "\n",
    "                try: option_info['strike'] = float(word)\n",
    "                except:pass\n",
    "    \n",
    "        if 'not confirm' in alert:\n",
    "            print(\"did not confirm\")\n",
    "            return False\n",
    "        \n",
    "        if option_info['bullish'] is not None and option_info['put'] is not None and option_info['strike'] is not None:\n",
    "            \n",
    "            if option_info['bullish'] != option_info['put']:\n",
    "                print(\"mismatch\")\n",
    "                option_info['put'] = not option_info['put']\n",
    "                \n",
    "            print(\"trade confirmed:\")\n",
    "            \n",
    "            print(option_info)\n",
    "                        \n",
    "            execute_trade(option_info)\n",
    "\n",
    "            \n",
    "            return False\n",
    "\n",
    "    return True\n",
    "\n",
    "\n",
    "def find_display(driver,info):\n",
    "    #cookie_login(driver,info)\n",
    "    manual_login(driver,info)\n",
    "    game_plan = driver.find_element_by_id('frmGameplan')\n",
    "    driver.switch_to.frame(game_plan)\n",
    "\n",
    "    display = driver.find_element_by_id('display')\n",
    "    return display\n",
    "    \n",
    "def find_alerts_and_times(display):\n",
    "    alerts = display.find_elements_by_class_name('alert')\n",
    "    times = display.find_elements_by_xpath('span')\n",
    "    return alerts,times\n",
    "    \n",
    "def test_page(info):\n",
    "    driver = webdriver.Chrome(\"/usr/local/bin/chromedriver\")\n",
    "    display = find_display(driver,info)\n",
    "    find_alerts_and_times(display)\n",
    "    tm.sleep(5)\n",
    "    driver.close()\n",
    "\n",
    "\n",
    "def monitor(driver,info,time_end):\n",
    "    \n",
    "    display = find_display(driver,info)\n",
    "        \n",
    "    date_text = display.find_element_by_xpath('h5').text\n",
    "    print(\"monitor date:\",date_text)\n",
    "    \n",
    "    stale_count = 0\n",
    "    \n",
    "    alert_texts = []\n",
    "\n",
    "    while datetime.datetime.now().time() < MONITOR_TIME_END:\n",
    "        \n",
    "        alerts,times = find_alerts_and_times(display)\n",
    "        \n",
    "        for alert,time in zip(alerts,times):\n",
    "                    \n",
    "            try:\n",
    "                alert_text = alert.text\n",
    "                time_text = time.text\n",
    "            except StaleElementReferenceException:\n",
    "                print(\"Exception: Stale Element\",stale_count)\n",
    "                stale_count = stale_count + 1\n",
    "                if stale_count == 5:\n",
    "                    return\n",
    "                else:\n",
    "                    tm.sleep(.2)\n",
    "                    break\n",
    "            else:\n",
    "                if alert_text not in alert_texts:\n",
    "                    alert_texts.append(alert_text)\n",
    "                \n",
    "                    print('[',time_text,']')\n",
    "                    print('[',alert_text,']')\n",
    "                        \n",
    "                    if not process_alerts(alert_texts):\n",
    "                        return\n",
    "\n",
    "                \n",
    "    \n",
    "\n",
    "#StaleElementReferenceException\n",
    "#NoSuchWindowException\n",
    "#WebDriverException"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df58a017",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Grabbing new access token...\n",
      "{'MSFT': {'52WkHigh': 271.65,\n",
      "          '52WkLow': 193.55,\n",
      "          'askId': 'P',\n",
      "          'askPrice': 270.85,\n",
      "          'askSize': 400,\n",
      "          'assetMainType': 'EQUITY',\n",
      "          'assetType': 'EQUITY',\n",
      "          'bidId': 'Q',\n",
      "          'bidPrice': 270.8,\n",
      "          'bidSize': 100,\n",
      "          'bidTick': ' ',\n",
      "          'closePrice': 271.4,\n",
      "          'cusip': '594918104',\n",
      "          'delayed': False,\n",
      "          'description': 'Microsoft Corporation - Common Stock',\n",
      "          'digits': 4,\n",
      "          'divAmount': 2.24,\n",
      "          'divDate': '2021-08-18 00:00:00.000',\n",
      "          'divYield': 0.83,\n",
      "          'exchange': 'q',\n",
      "          'exchangeName': 'NASD',\n",
      "          'highPrice': 0.0,\n",
      "          'lastId': 'Q',\n",
      "          'lastPrice': 270.85,\n",
      "          'lastSize': 0,\n",
      "          'lowPrice': 0.0,\n",
      "          'marginable': True,\n",
      "          'mark': 270.85,\n",
      "          'markChangeInDouble': -0.55,\n",
      "          'markPercentChangeInDouble': -0.2027,\n",
      "          'nAV': 0.0,\n",
      "          'netChange': -0.55,\n",
      "          'netPercentChangeInDouble': -0.2027,\n",
      "          'openPrice': 0.0,\n",
      "          'peRatio': 36.5712,\n",
      "          'quoteTimeInLong': 1625059051938,\n",
      "          'realtimeEntitled': True,\n",
      "          'regularMarketLastPrice': 271.4,\n",
      "          'regularMarketLastSize': 16054,\n",
      "          'regularMarketNetChange': 0.0,\n",
      "          'regularMarketPercentChangeInDouble': 0.0,\n",
      "          'regularMarketTradeTimeInLong': 1624996801042,\n",
      "          'securityStatus': 'Normal',\n",
      "          'shortable': True,\n",
      "          'symbol': 'MSFT',\n",
      "          'totalVolume': 97004,\n",
      "          'tradeTimeInLong': 1625059064426,\n",
      "          'volatility': 0.026}}\n",
      "Starting system at: 2021-06-30 06:17:59.896367\n",
      "waking_up 2021-06-30 06:18:00.397308\n",
      "monitor date: June 30, 2021\n",
      "[ 09:12:00 ]\n",
      "[ ×\n",
      "There is no chance of a trade today. Today's market conditions do not show a clear historical edge. This is today's final message. ]\n",
      "final message\n",
      "back to sleep: 2021-06-30 06:18:08.846794\n",
      "Waiting till: 06:40:00\n",
      "Wait finished 2021-06-30 06:40:00.289930\n"
     ]
    }
   ],
   "source": [
    "\n",
    "test_td()\n",
    "test_page(info)\n",
    "\n",
    "print('Starting system at:',datetime.datetime.now())\n",
    "\n",
    "\n",
    "\n",
    "while (True):\n",
    "    \n",
    "    if TEST_PATH is not None or TEST_STRIKE is not None:\n",
    "        MONITOR_TIME_START = datetime.datetime.now().time()\n",
    "        MONITOR_TIME_END = (datetime.datetime.combine(datetime.date.today(),MONITOR_TIME_START) + datetime.timedelta(seconds=90)).time()\n",
    "\n",
    "    \n",
    "    tm.sleep(.5)\n",
    "    \n",
    "    if datetime.datetime.now().time() <= MONITOR_TIME_START or datetime.datetime.now().time() > MONITOR_TIME_END:\n",
    "        continue\n",
    "        \n",
    "    print('waking_up',datetime.datetime.now())\n",
    "    \n",
    "    driver = webdriver.Chrome(\"/usr/local/bin/chromedriver\")\n",
    "\n",
    "    try:\n",
    "        \n",
    "        monitor(driver,info,MONITOR_TIME_END)\n",
    "        \n",
    "    except NoSuchWindowException:\n",
    "        print(\"no such window exception\")\n",
    "        \n",
    "    except WebDriverException:\n",
    "        print(\"web driver exception\")\n",
    "        \n",
    "    except MaxOrdersReachedError:\n",
    "        print(\"error max orders reached\")\n",
    "        \n",
    "            \n",
    "    print('back to sleep:',datetime.datetime.now())\n",
    "    \n",
    "    driver.quit()\n",
    "    \n",
    "    print(\"Waiting till:\",MONITOR_TIME_END)\n",
    "    while datetime.datetime.now().time() < MONITOR_TIME_END:\n",
    "        tm.sleep(1)\n",
    "    print(\"Wait finished\",datetime.datetime.now())\n",
    "        \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65209f94",
   "metadata": {},
   "outputs": [],
   "source": [
    "#to set the cookies, load home below.  Log in, then pickle the cookies in next frame\n",
    "\n",
    "from selenium import webdriver\n",
    "\n",
    "def load_home():\n",
    "    driver = webdriver.Chrome(\"/usr/local/bin/chromedriver\")\n",
    "    info = {}\n",
    "    info['url'] = 'https://www.smbtraining.com/'\n",
    "    driver.get(info['url'])\n",
    "    return driver\n",
    "#driver = load_home()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c437c77c",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pickle\n",
    "#only need to do once when logging in for first time.  This will save the login cookie which is loaded above\n",
    "#pickle.dump(driver.get_cookies(), open(COOKIE_PATH,\"wb\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19a4bf5b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b08d2c5e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "dct = {}\n",
    "dct['url1'] = ''\n",
    "dct['url2'] = ''\n",
    "dct['user'] =  ''\n",
    "dct['pwd'] = ''\n",
    "#with open('/home/cc/woim','w') as outfile:\n",
    "#    json.dump(dct,outfile)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35cb91e8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ea7507c",
   "metadata": {},
   "outputs": [],
   "source": [
    "t1 = 'There is no chance of a trade today. Today's market conditions do not show a clear historical edge. This is today's final message.t1 = 'There is a 75% chance of a bullish signal this morning. Please be prepared to enter a put credit spread trade.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32ba5fdc",
   "metadata": {},
   "outputs": [],
   "source": [
    "t2 = 'did not confirm a bullish trade this morning and therefore there will be no trade.'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42dda668",
   "metadata": {},
   "outputs": [],
   "source": [
    "t2 = ' is suggesting a bullish trade this morning: an $SPX index put credit spread trade, expiring today, with a short strike of 4090'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eecb5666",
   "metadata": {},
   "outputs": [],
   "source": [
    "session = get_TDSession()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a6e60c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "strike_sell = 4180\n",
    "strike_buy = 4170\n",
    "quantity = 1\n",
    "\n",
    "def get_info(session,strike_sell,strike_buy):\n",
    "\n",
    "    sell_info,buy_info = get_leg_info(session,'$SPX.X','put',strike_sell,strike_buy,datetime.datetime.now().time())\n",
    "    \n",
    "    return sell_info,buy_info\n",
    "\n",
    "print(datetime.datetime.now())\n",
    "for i in range(1):\n",
    "    sell_info,buy_info = get_info(session,strike_sell,strike_buy)\n",
    "    print(sell_info['totalVolume'],datetime.datetime.fromtimestamp(sell_info['quoteTimeInLong']/1000))\n",
    "    \n",
    "print(datetime.datetime.now())\n",
    "\n",
    "    \n",
    "print(sell_info['ask'],sell_info['bid'],sell_info['theoreticalOptionValue'],sell_info['totalVolume'],sell_info['tradeTimeInLong'],sell_info['quoteTimeInLong'])\n",
    "print(buy_info['ask'],buy_info['bid'],buy_info['theoreticalOptionValue'],buy_info['totalVolume'])\n",
    "\n",
    "mid_price = (sell_info['ask'] + sell_info['bid'])/2 - (buy_info['ask'] + buy_info['bid'])/2\n",
    "print(\"mid_price = \",mid_price)\n",
    "theoretical_price = sell_info['theoreticalOptionValue'] - buy_info['theoreticalOptionValue']\n",
    "print(\"theoretical_price = \",round(theoretical_price,2))\n",
    "\n",
    "print(datetime.datetime.fromtimestamp(sell_info['quoteTimeInLong']/1000))\n",
    "\n",
    "premium = quantity * mid_price\n",
    "risk = quantity * (strike_sell - strike_buy)\n",
    "print(\"premium = \",round(premium,2))\n",
    "print(\"risk = \",risk)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "02c60fd1",
   "metadata": {},
   "outputs": [],
   "source": [
    "strike_sell = 4180\n",
    "strike_buy = 4175\n",
    "quantity = 4\n",
    "\n",
    "def get_info(session,strike_sell,strike_buy):\n",
    "\n",
    "    sell_info,buy_info = get_leg_info(session,'$SPX.X','put',strike_sell,strike_buy,datetime.datetime.now().time())\n",
    "    \n",
    "    return sell_info,buy_info\n",
    "\n",
    "print(datetime.datetime.now())\n",
    "for i in range(1):\n",
    "    sell_info,buy_info = get_info(session,strike_sell,strike_buy)\n",
    "    print(sell_info['totalVolume'],datetime.datetime.fromtimestamp(sell_info['quoteTimeInLong']/1000))\n",
    "    \n",
    "print(datetime.datetime.now())\n",
    "\n",
    "    \n",
    "print(sell_info['ask'],sell_info['bid'],sell_info['theoreticalOptionValue'],sell_info['totalVolume'],sell_info['tradeTimeInLong'],sell_info['quoteTimeInLong'])\n",
    "print(buy_info['ask'],buy_info['bid'],buy_info['theoreticalOptionValue'],buy_info['totalVolume'])\n",
    "\n",
    "mid_price = (sell_info['ask'] + sell_info['bid'])/2 - (buy_info['ask'] + buy_info['bid'])/2\n",
    "print(\"mid_price = \",mid_price)\n",
    "print(\"theoretical_price = \",sell_info['theoreticalOptionValue'] - buy_info['theoreticalOptionValue'])\n",
    "\n",
    "print(datetime.datetime.fromtimestamp(sell_info['quoteTimeInLong']/1000))\n",
    "\n",
    "premium = quantity * mid_price\n",
    "risk = quantity * (strike_sell - strike_buy)\n",
    "print(\"premium = \",premium)\n",
    "print(\"risk = \",risk)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9c359a89",
   "metadata": {},
   "source": [
    "# manual log in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8078bed",
   "metadata": {},
   "outputs": [],
   "source": [
    "from selenium import webdriver\n",
    "from selenium.common.exceptions import NoSuchElementException\n",
    "import time as tm\n",
    "import json\n",
    "\n",
    "with open('/home/cc/woim',\"r\") as read_file:\n",
    "    cred = json.load(read_file)\n",
    "\n",
    "driver = webdriver.Chrome(\"/usr/local/bin/chromedriver\")\n",
    "\n",
    "def wait_for_element(func,id,tries):\n",
    "    while True:\n",
    "        try:\n",
    "            form = func(id)\n",
    "            return form\n",
    "        \n",
    "        except NoSuchElementException as e:\n",
    "            tries -= 1\n",
    "            if not tries:\n",
    "                raise e\n",
    "            tm.sleep(.1)\n",
    "    \n",
    "\n",
    "def manual_login(driver,cred):\n",
    "\n",
    "    driver.get(cred['url1'])\n",
    "    log_in = driver.find_element_by_xpath(\"// a[contains(text(),'Login')]\")\n",
    "    log_in.click()\n",
    "    \n",
    "    form = wait_for_element(driver.find_element_by_id,'user-login',10)\n",
    "\n",
    "\n",
    "    edit_name = form.find_element_by_id(\"edit-name\")\n",
    "    edit_pass = form.find_element_by_id(\"edit-pass\")\n",
    "    edit_submit = form.find_element_by_id(\"edit-submit\")\n",
    "    edit_name.send_keys(cred['user'])\n",
    "    edit_pass.send_keys(cred['pwd'])\n",
    "    edit_submit.click()\n",
    "    \n",
    "    log_in = wait_for_element(driver.find_element_by_xpath,\"// a[contains(text(),'Member Area')]\",120)\n",
    "\n",
    "manual_login(driver,cred)\n",
    "\n",
    "driver.get(cred['url2'])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18158033",
   "metadata": {},
   "outputs": [],
   "source": [
    "driver = webdriver.Chrome(\"/usr/local/bin/chromedriver\")\n",
    "display = find_display(driver,info)\n",
    "\n",
    "date_text = display.find_element_by_xpath('h5').text\n",
    "print(\"monitor date:\",date_text)\n",
    "\n",
    "\n",
    "#alerts = display.find_elements_by_class_name('alert')\n",
    "#times = display.find_elements_by_xpath('span')\n",
    "\n",
    "alerts,times = find_alerts_and_times(display)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21bbb782",
   "metadata": {},
   "outputs": [],
   "source": [
    "alerts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f7c9cc17",
   "metadata": {},
   "outputs": [],
   "source": [
    "times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f458b478",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(alerts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee73b016",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(times)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7adee71",
   "metadata": {},
   "source": [
    "# show prices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a00c671b",
   "metadata": {},
   "outputs": [],
   "source": [
    "TDSession = get_TDSession()\n",
    "\n",
    "put_spread_strike = 4160\n",
    "width = 5\n",
    "\n",
    "sell_limit_vertical_spread = create_order_payload(TDSession,'$SPX.X',1,'put',put_spread_strike,put_spread_strike-width,datetime.datetime.now().date(),mid_offset = 0)\n",
    "\n",
    "print(sell_limit_vertical_spread['price'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d2df76e",
   "metadata": {},
   "outputs": [],
   "source": [
    "width = 10\n",
    "\n",
    "sell_limit_vertical_spread = create_order_payload(TDSession,'$SPX.X',1,'put',put_spread_strike,put_spread_strike-width,datetime.datetime.now().date(),mid_offset = 0)\n",
    "\n",
    "print(sell_limit_vertical_spread['price'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5bbcd900",
   "metadata": {},
   "outputs": [],
   "source": [
    "width = 15\n",
    "\n",
    "sell_limit_vertical_spread = create_order_payload(TDSession,'$SPX.X',1,'put',put_spread_strike,put_spread_strike-width,datetime.datetime.now().date(),mid_offset = 0)\n",
    "\n",
    "print(sell_limit_vertical_spread['price'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f43e1ca2",
   "metadata": {},
   "outputs": [],
   "source": [
    "width = 20\n",
    "\n",
    "sell_limit_vertical_spread = create_order_payload(TDSession,'$SPX.X',1,'put',put_spread_strike,put_spread_strike-width,datetime.datetime.now().date(),mid_offset = 0)\n",
    "\n",
    "print(sell_limit_vertical_spread['price'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2caebaa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "datetime.datetime.now().date()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0241d363",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}