test_stock.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "you are using nologin method, data you access may be limited\n"
     ]
    }
   ],
   "source": [
    "# version 3\n",
    "from trade_algorithm import indicators\n",
    "from tvDatafeed import TvDatafeed\n",
    "import pandas as pd\n",
    "import os\n",
    "import datetime\n",
    "import numpy as np\n",
    "from sklearn import preprocessing\n",
    "import pythainav as nav\n",
    "from binance.client import Client\n",
    "from utils import get_data, load_data, read_config\n",
    "\n",
    "\n",
    "pd.set_option('display.max_rows', 30)\n",
    "pd.set_option('display.max_columns', 30)\n",
    "pd.set_option('display.width', 1000)\n",
    "\n",
    "tv = TvDatafeed(username=None,password=None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "exchange: stable_coin\n",
      "List stock name of the lowest close value in the 62 days\n",
      "stock min day: []\n",
      "----------------------------------------------------------------------------------------------------\n",
      "List stock name of the lowest close value in the 93 days\n",
      "stock min day: []\n",
      "----------------------------------------------------------------------------------------------------\n",
      "List stock name of the lowest close value in the 124 days\n",
      "stock min day: []\n",
      "----------------------------------------------------------------------------------------------------\n",
      "List stock name of the lowest close value in the 155 days\n",
      "stock min day: []\n",
      "----------------------------------------------------------------------------------------------------\n",
      "List stock name of the lowest close value in the 365 days\n",
      "stock min day: []\n",
      "----------------------------------------------------------------------------------------------------\n",
      "days: 365\n",
      "----------------------------------------------------------------------------------------------------\n",
      "AVAXBUSD 49.1301260378126\n",
      "ADABUSD 45.410182054618204\n",
      "SOLBUSD 35.34016805041681\n",
      "BTCBUSD 34.640028008402794\n",
      "BNBBUSD 32.920084025208396\n",
      "ETHBUSD 26.780056016805602\n",
      "DOGEBUSD 23.55021006302101\n",
      "XRPBUSD 23.270154046215406\n",
      "----------------------------------------------------------------------------------------------------\n",
      "The name of the stock that has reached the lowest price in [62, 93, 124, 155, 365] days\n",
      "the name of stock is trend up\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# list stock config\n",
    "json_stock = read_config(os.path.join(os.getcwd(),'config','list_stock','stock_config.json'))\n",
    "assert json_stock is not None, \"error read stock config\"\n",
    "\n",
    "# indicator config for long term\n",
    "indicator_config_long = read_config(os.path.join(os.getcwd(),'config','indicator','long_indicator.json'))\n",
    "assert indicator_config_long is not None, \"error read indicator config (long term)\"\n",
    "\n",
    "# indicator config for short term\n",
    "indicator_config_short = read_config(os.path.join(os.getcwd(),'config','indicator','short_indicator.json'))\n",
    "assert indicator_config_short is not None, \"error read indicator config (short term)\"\n",
    "\n",
    "# config\n",
    "config = read_config(os.path.join(os.getcwd(),'config','config.json'))\n",
    "assert config is not None, \"error read config\"\n",
    "\n",
    "# find current date\n",
    "current_date = datetime.datetime.today().date()\n",
    "\n",
    "indicator_engine = indicators()\n",
    "\n",
    "# prepare config\n",
    "mode = config['mode']\n",
    "max_days = config[mode]['len_data']\n",
    "max_days = max(max_days)\n",
    "\n",
    "for key_exc in json_stock[f'list_{mode}']:\n",
    "    print(f'exchange: {key_exc}')\n",
    "\n",
    "    dict_min_value_1 = {}\n",
    "    dict_min_value_2 = {}\n",
    "    dict_remaining_date = {}\n",
    "    dict_pair_daywithscore = {\n",
    "        \"stock_score\":[],\n",
    "        \"min_date\":[]\n",
    "    }\n",
    "\n",
    "    dict_stock_name_score = {}\n",
    "    for namest2dict in json_stock[f'list_{mode}'][key_exc]:\n",
    "        dict_stock_name_score.update({namest2dict:0})\n",
    "        dict_remaining_date.update({namest2dict:{}})\n",
    "        for t in config[mode]['len_data']:\n",
    "            dict_remaining_date[namest2dict].update({f\"{t}\":0})\n",
    "\n",
    "    for namest in json_stock[f'list_{mode}'][key_exc]:\n",
    "        if config['fetch_newdata'] == \"on\":\n",
    "            try:\n",
    "                data = get_data(tv, nav, Client, key_exc, namest, max_days, mode, config[mode])\n",
    "                if len(data) == 0:\n",
    "                    continue\n",
    "            except Exception as e:\n",
    "                print(f'stock name: {namest}')\n",
    "                print(f'error: {e}')\n",
    "                continue\n",
    "        else:\n",
    "            data = load_data(namest, mode, key_exc, max_days)\n",
    "\n",
    "        score = 0\n",
    "        # first indicators\n",
    "        for indicator in config[mode]['long_indicators']:\n",
    "            # print('indicator:',indicator)\n",
    "            score += indicator_engine.process(f\"{indicator}\", data, indicator_config_long[f'{indicator}'])\n",
    "        \n",
    "        # print('score:',score)\n",
    "        dict_stock_name_score[namest] = score\n",
    "\n",
    "        for t in config[mode]['len_data']:\n",
    "            data_follow_time = load_data(namest, mode, key_exc, t)\n",
    "\n",
    "            # find min value in dataframe\n",
    "            data_cal_number_days = data_follow_time[data_follow_time['close'] == min(list(data_follow_time['close']))]\n",
    "\n",
    "            # convert timestamp to datetime.date\n",
    "            if len(data_cal_number_days) > 1:\n",
    "                data_cal_number_days = data_cal_number_days.iloc[-1,:]\n",
    "                date_min_value = data_cal_number_days['datetime'].to_pydatetime().date()\n",
    "            else:\n",
    "                # convert numpy.datetime64 to datetime\n",
    "                date_min_value = pd.to_datetime(data_cal_number_days['datetime'].values[0]).to_pydatetime().date()\n",
    "            # date_min_value = data_cal_number_days['datetime'].to_pydatetime().date()\n",
    "            remaining_date = current_date - date_min_value\n",
    "            \n",
    "            df_min_value = data_follow_time[data_follow_time['close'] == min(list(data_follow_time['close']))]\n",
    "            df_current_value = data_follow_time.iloc[-2:-1,:]\n",
    "            if t == 62:\n",
    "                dict_remaining_date[namest][f'{t}'] = remaining_date.days\n",
    "                dict_min_value_1[namest] = float(df_current_value['close'].values[0]) - float(min(list(data_follow_time['close'])))\n",
    "            else:\n",
    "                dict_remaining_date[namest][f'{t}'] = remaining_date.days\n",
    "                dict_min_value_2[namest] = float(df_current_value['close'].values[0]) - float(min(list(data_follow_time['close'])))\n",
    "            \n",
    "    # sort data by current close value minus the smallest a value in the past\n",
    "    dict_min_value_1_sort = dict(sorted(dict_min_value_1.items(), key=lambda item: item[1], reverse=True))\n",
    "    dict_min_value_2_sort = dict(sorted(dict_min_value_2.items(), key=lambda item: item[1], reverse=True))\n",
    "\n",
    "    # increse score following by date\n",
    "    dict_prepare_sort = {}\n",
    "    score_follow_time = 0.5\n",
    "    for data_v in config[mode]['len_data']:\n",
    "        for key,_ in dict_remaining_date.items():\n",
    "            dict_prepare_sort[key] = dict_remaining_date[key][f\"{data_v}\"]\n",
    "        \n",
    "        dict_remaining_date_sort = dict(sorted(dict_prepare_sort.items(), key=lambda item: item[1],reverse=True))\n",
    "        list_score = [i+score_follow_time for i in range(10)]\n",
    "\n",
    "        reverse_date_tomin_first = dict(sorted(dict_remaining_date_sort.items(), key=lambda item: item[1]))\n",
    "        \n",
    "        print(f'List stock name of the lowest close value in the {data_v} days')\n",
    "        for k,v in reverse_date_tomin_first.items():\n",
    "            if int(v) <= 10:\n",
    "                dict_pair_daywithscore['min_date'].append(k)\n",
    "                print(k,v)\n",
    "        print('stock min day:',dict_pair_daywithscore['min_date'])\n",
    "        print('-'*100)\n",
    "\n",
    "        for add_score, key_score in zip(list_score,list(dict_remaining_date_sort.keys())[:10]):\n",
    "            dict_stock_name_score[key_score] = dict_stock_name_score[key_score] + add_score\n",
    "\n",
    "        score_follow_time+=0.5        \n",
    "        \n",
    "        # loop increase score\n",
    "    for dict_sort_value in [dict_min_value_1_sort, dict_min_value_2_sort]:\n",
    "        # print('dict_sort_value:',dict_sort_value)\n",
    "        # normalize score\n",
    "        list_score = [i*1000 for i in range(1,len(dict_sort_value)+1)]\n",
    "        np_score = np.array(list_score)\n",
    "        normalized_arr = preprocessing.normalize([np_score])\n",
    "        # print('normalize:',normalized_arr.tolist()[0])\n",
    "\n",
    "        dict_score = {} \n",
    "        for score,(k,v) in zip(normalized_arr.tolist()[0],dict_sort_value.items()):\n",
    "            dict_score.update({k:score})\n",
    "\n",
    "        # print('dict_score:',dict_score)\n",
    "        for k,v in dict_score.items():\n",
    "            dict_stock_name_score[k] = dict_stock_name_score[k] + dict_score[k]\n",
    "\n",
    "\n",
    "    # print('score:',dict_stock_name_score)\n",
    "    dict_stock_name_score_sort = dict(sorted(dict_stock_name_score.items(), key=lambda item: item[1], reverse=True))\n",
    "\n",
    "    # print('dict_stock_name_score_sort final:',dict_stock_name_score_sort)\n",
    "    \n",
    "    print(f'days: {max_days}')\n",
    "    print('-'*100)\n",
    "    int_check = 0\n",
    "    for k,v in dict_stock_name_score_sort.items():\n",
    "        dict_pair_daywithscore['stock_score'].append(k)\n",
    "        print(k,v)\n",
    "        int_check+=1\n",
    "        if int_check >=10:\n",
    "            break\n",
    "    print('-'*100)\n",
    "\n",
    "    # pair\n",
    "    print(f'The name of the stock that has reached the lowest price in {config[mode][\"len_data\"]} days')\n",
    "    dict_pair_daywithscore['stock_score'] = dict_pair_daywithscore['stock_score'][:10]\n",
    "    for stock_sc in dict_pair_daywithscore['stock_score']:\n",
    "        if stock_sc in dict_pair_daywithscore['min_date']:\n",
    "            # list_date_less_than_10.append(stock_sc)\n",
    "            print(stock_sc)\n",
    "\n",
    "    # testing\n",
    "    # trend up \n",
    "    dict_stock_trend_up = {}\n",
    "    for tup in dict_pair_daywithscore['min_date']:\n",
    "        dict_stock_trend_up.update({tup:0})\n",
    "\n",
    "    for tup in dict_pair_daywithscore['min_date']:\n",
    "        try:\n",
    "            # data = get_data(tv, key_exc, tup, days)\n",
    "            # data = data.reset_index()\n",
    "            data = load_data(namest, mode, key_exc, t)\n",
    "        except Exception as e:\n",
    "            print(f'stock name: {tup}')\n",
    "            print(f'error: {e}')\n",
    "            continue\n",
    "\n",
    "        score = 0\n",
    "        # first indicators\n",
    "        for indicator in config[mode]['short_indicators']:\n",
    "            # print('indicator:',indicator)\n",
    "            score += indicator_engine.process(f\"{indicator}\", data, indicator_config_short[f'{indicator}'])\n",
    "\n",
    "        dict_stock_trend_up[tup] = score\n",
    "\n",
    "    dict_stock_trend_up_sort = dict(sorted(dict_stock_trend_up.items(), key=lambda item: item[1], reverse=True))\n",
    "    print('the name of stock is trend up')\n",
    "    for k,v in dict_stock_trend_up_sort.items():\n",
    "        print(k,v)\n",
    "\n",
    "    print()\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.13 ('stock')",
   "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.9.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "62bf5572cc101ed9ae4fde5815e6644554f95a90271476078347a0a4f775b5be"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}