Update rsi and ichimoku api

models/ichimoku.py

@@ -3,11 +3,15 @@ from pydantic import BaseModel, root_validator
 
 class IchimokuPayload(BaseModel):
     symbol: str
-    count_back: int = 365
-    type: str = "stock"
+    count_back: int = 200
+    symbol_type: str = "stock"
+    conversion_period: int = 9
+    base_period: int = 26
+    span_b_period: int = 52
+    displacement: int = 26
 
     @root_validator
     def validate_dates(cls, values):
-        if values['type'] not in ["index", "stock"]:
+        if values['symbol_type'] not in ["index", "stock"]:
             raise ValueError('type should be index or stock')
         return values

models/price.py

@@ -4,10 +4,10 @@ from pydantic import BaseModel, root_validator
 class PricePayload(BaseModel):
     symbol: str
     count_back: int = 365
-    type: str = "stock"
+    symbol_type: str = "stock"
 
     @root_validator
     def validate_dates(cls, values):
-        if values['type'] not in ["index", "stock"]:
+        if values['symbol_type'] not in ["index", "stock"]:
             raise ValueError('type should be index or stock')
         return values

models/rsi.py

@@ -3,7 +3,6 @@ from pydantic import BaseModel
 
 class RSIPayload(BaseModel):
     symbol: str
-    range_selector: str = "1y"
     periods: int = 14
     smooth_k: int = 3
     smooth_d: int = 3

routes/data.py

@@ -17,7 +17,7 @@ router = APIRouter()
 async def get_price_data(payload: PricePayload) -> Sequence[dict]:
     price_df = Indicator.get_price(payload.symbol,
                                    payload.count_back,
-                                   payload.type)
+                                   payload.symbol_type)
     return json.loads(price_df.to_json(orient="records"))
 
 
@@ -29,7 +29,6 @@ async def get_price_data(payload: PricePayload) -> Sequence[dict]:
 async def get_rsi_data(payload: RSIPayload) -> Sequence[dict]:
     rsi_df = Indicator.get_rsi(
         payload.symbol,
-        payload.range_selector,
         payload.periods,
         payload.smooth_k,
         payload.smooth_d
@@ -45,6 +44,10 @@ async def get_rsi_data(payload: RSIPayload) -> Sequence[dict]:
 async def get_ichimoku_data(payload: IchimokuPayload) -> Sequence[dict]:
     price_df = Indicator.get_price(payload.symbol,
                                    payload.count_back,
-                                   payload.type)
-    ichimoku_df = Indicator.get_ichimoku_cloud(price_df)
+                                   payload.symbol_type)
+    ichimoku_df = Indicator.get_ichimoku_cloud(price_df,
+                                               payload.conversion_period,
+                                               payload.base_period,
+                                               payload.span_b_period,
+                                               payload.displacement)
     return json.loads(ichimoku_df.to_json(orient="records"))

services/indicator.py

@@ -1,10 +1,11 @@
 import requests
-import json
 from datetime import datetime, timedelta
 import pandas as pd
 import numpy as np
-from vnstock import longterm_ohlc_data
-from .utils import Utility
+from vnstock import longterm_ohlc_data, stock_historical_data, price_board
+from pymongo import MongoClient, ASCENDING, DESCENDING
+from utils.config import DATE_FORMAT
+import os
 
 PREFIX = "https://www.hsx.vn/Modules/Chart/StaticChart/"
 TIME = {"1m": 2, "3m": 3, "6m": 4, "1y": 5, "2y": 6, "5y": 7}
@@ -24,49 +25,84 @@ class Indicator:
 
     @staticmethod
     def get_price(symbol: str,
-                  count_back: int = 365,
-                  type: str = "stock",) -> pd.DataFrame:
+                  count_back: int = 100,
+                  symbol_type: str = "stock",) -> pd.DataFrame:
         resolution = "D"
         end_date = datetime.now()
         delta = timedelta(days=count_back)
         start_date = end_date - delta
         start_date = datetime.strftime(start_date, '%Y-%m-%d')
         end_date = datetime.strftime(end_date, '%Y-%m-%d')
-        return longterm_ohlc_data(symbol, start_date, end_date,
-                                  resolution, type).reset_index()
+        df = longterm_ohlc_data(symbol, start_date, end_date,
+                                resolution, symbol_type).reset_index(drop=True)
+        df[['open', 'high', 'low', 'close']] = \
+            df[['open', 'high', 'low', 'close']] * 1000
+        # convert open, high, low, close to int
+        df[['open', 'high', 'low', 'close']] = \
+            df[['open', 'high', 'low', 'close']].astype(int)
+        return df
 
     @staticmethod
     def get_rsi(
         symbol: str,
-        range_selector: str = "1y",
         periods: int = 14,
         smooth_k: int = 3,
         smooth_d: int = 3,
     ) -> pd.DataFrame:
-        range_selector = TIME[range_selector]
-        params = {
-            "stockSymbol": symbol,
-            "rangeSelector": range_selector,
-            "period": periods,
-        }
-        lst_param = []
-        for key, value in params.items():
-            lst_param.append(f"{key}={value}")
-        url = PREFIX + INDICATORS["RSI"] + "?" + "&".join(lst_param)
-        response = requests.get(url)
-        data = json.loads(response.text)
-        rsi_df = pd.DataFrame(data["SeriesColection"][0]["Points"])
-        rsi_df["time"] = \
-            rsi_df["Time"].apply(lambda x: Utility.ts_to_date(x/1000))
-        rsi_df["rsi"] = rsi_df["Value"].apply(lambda x: x[0])
-        rsi_df = rsi_df[["date", "rsi"]]
-        rsi_df["stoch_rsi"] = Indicator.stoch_rsi(rsi_df["rsi"], periods)
-        rsi_df["stoch_rsi_smooth_k"] = \
-            Indicator.stoch_rsi_smooth_k(rsi_df["stoch_rsi"], smooth_k)
-        rsi_df["stoch_rsi_smooth_d"] = Indicator.stoch_rsi_smooth_d(
-            rsi_df["stoch_rsi_smooth_k"], smooth_d
-        )
-        return rsi_df
+        try:
+            symbol = symbol.upper()
+            uri = os.environ.get("MONGODB_URI")
+            client = MongoClient(uri)
+            database = client.get_database("data")
+            collection = database.get_collection("rsi")
+            datetime_now = datetime.utcnow()
+            hour = datetime_now.hour
+            weekday = datetime_now.weekday()
+            error = False
+            if weekday < 5 and hour >= 12:  # Check if data is updated
+                newest_record = collection.find_one(sort=[("_id", DESCENDING)])
+                delta = timedelta(days=20)
+                start_date = datetime_now - delta
+                start_date = start_date.strftime(DATE_FORMAT)
+                end_date = datetime_now.strftime(DATE_FORMAT)
+                tmp_df = stock_historical_data("MBB", start_date, end_date)
+                last_date = str(tmp_df["time"].iloc[-1])
+                if newest_record["time"] != last_date:
+                    try:
+                        lst_symbols = list(newest_record.keys())[2:]
+                        record = {}
+                        record["time"] = last_date
+                        for s in lst_symbols:
+                            url = PREFIX + INDICATORS["RSI"] + \
+                                f"?stockSymbol={symbol}\
+                                    &rangeSelector=0\
+                                        &periods={periods}"
+                            data = requests.get(url).json()
+                            lst_rsi = data["SeriesColection"][0]["Points"]
+                            record[s] = lst_rsi[-1]["Value"][0]
+                        collection.find_one_and_delete(
+                            sort=[("_id", ASCENDING)])
+                        collection.insert_one(record)
+                        print("Updated data")
+                    except Exception:
+                        error = True
+            records = list(collection.find())
+            record_df = pd.DataFrame(records).drop(columns=["_id"])
+            record_df = \
+                record_df[["time", symbol]].rename(columns={symbol: "rsi"})
+            if error:
+                new_df = price_board(symbol)
+                record_df.loc[len(record_df)] = new_df[["time", "RSI"]].values
+            record_df["stoch_rsi"] = \
+                Indicator.stoch_rsi(record_df["rsi"], periods)
+            record_df["stoch_rsi_smooth_k"] = \
+                Indicator.stoch_rsi_smooth_k(record_df["stoch_rsi"], smooth_k)
+            record_df["stoch_rsi_smooth_d"] = Indicator.stoch_rsi_smooth_d(
+                record_df["stoch_rsi_smooth_k"], smooth_d
+            )
+            return record_df
+        except Exception:
+            return None
 
     @staticmethod
     def stoch_rsi(rsi: pd.Series, periods: int = 14) -> pd.Series: