Added:

Stock Analysis:
OHLC Plot
Chaikin, MACD indicator,
Candlestick Pattern recognition

Intraday Analysis:
Barrier Hit probability
VWAP analysis

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

PatternRecognition.py

@@ -1,8 +1,9 @@
-import talib
+import talib as ta
 import pandas as pd
+import numpy as np
 
 def GetPatternForData(stock_data_df):
-    candle_name_list = talib.get_function_groups()['Pattern Recognition']
+    candle_name_list = ta.get_function_groups()['Pattern Recognition']
     tech_analysis_df = stock_data_df.iloc[-10:].copy()
     op_df = tech_analysis_df.Open
     hi_df = tech_analysis_df.High
@@ -10,14 +11,30 @@ def GetPatternForData(stock_data_df):
     cl_df = tech_analysis_df.Close
 
     for candle in candle_name_list:
-        tech_analysis_df[candle] = getattr(talib, candle)(op_df, hi_df, lo_df, cl_df)
+        tech_analysis_df[candle] = getattr(ta, candle)(op_df, hi_df, lo_df, cl_df)
 
-    result = pd.DataFrame(tech_analysis_df[['Date']+candle_name_list].sum(),columns=['Count'])
-    filtered_results = result[result.Count!=0]
+    result = pd.DataFrame(tech_analysis_df[['Date']+candle_name_list].sum(), columns=['Count'])
+    filtered_results = result[result.Count != 0]
 
     if filtered_results.empty:
-        return None,tech_analysis_df
+        return None, tech_analysis_df
     else:
-        return filtered_results[filtered_results.Count == filtered_results.Count.max()].index[0],tech_analysis_df
+        return filtered_results[filtered_results.Count == filtered_results.Count.max()].index[0], tech_analysis_df
 
-    return None,tech_analysis_df
+    return None, tech_analysis_df
+
+def ComputeChaikinADSignal(stock_data_df):
+    ADOSC_data = stock_data_df.copy()
+    ADOSC_data['ADOSC'] = ta.ADOSC(ADOSC_data.High, ADOSC_data.Low, ADOSC_data.Close, ADOSC_data.Volume,
+                                   fastperiod=3, slowperiod=10)
+    ADOSC_data.dropna(inplace=True)
+    ADOSC_data['ADOSC_chg'] = np.log(ADOSC_data['ADOSC']/ADOSC_data['ADOSC'].shift(1))
+    ADOSC_data.dropna(inplace=True)
+    return ADOSC_data
+
+def ComputeMACDSignal(stock_data_df):
+    macd_data_df = stock_data_df.copy()
+    macd_data_df['macd'], macd_data_df['macdsignal'], macd_data_df['macdhist'] =\
+        ta.MACD(macd_data_df.Close, fastperiod=12, slowperiod=26, signalperiod=9)
+    macd_data_df.dropna(inplace=True)
+    return macd_data_df

TopMovers.py

@@ -0,0 +1,21 @@
+from nsetools import Nse
+import pandas as pd
+from collections import OrderedDict
+
+nse = Nse()
+
+def GetTopLosers():
+    try:
+        top5losers = nse.get_top_losers()[:5]
+        data = OrderedDict({'Symbol': [i['symbol'] for i in top5losers], '%Change': [str(i['netPrice'])+'%' for i in top5losers]})
+        return pd.DataFrame(data).set_index('Symbol')
+    except:
+        return None
+
+def GetTopGainers():
+    try:
+        top5gainers = nse.get_top_gainers()[:5]
+        data = OrderedDict({'Symbol': [i['symbol'] for i in top5gainers], '%Change': [str(i['netPrice'])+'%' for i in top5gainers]})
+        return pd.DataFrame(data).set_index('Symbol')
+    except:
+        return None

main.py

@@ -2,10 +2,19 @@ import streamlit as st
 from nsetools import Nse
 from nsepy import get_history
 from datetime import date, timedelta
-from PatternRecognition import GetPatternForData
+from PatternRecognition import *
 from VixAnalysis import *
-
+from TopMovers import *
+import time
+from scipy.stats import norm
+from math import exp, log, sqrt
+import numpy as np
+import pandas as pd
 import yfinance as yf
+from plotly.subplots import make_subplots
+from random import randrange
+
+buy_sell_color_dict = {"Buy":"green", "Sell":"red", "Hold":"yellow"}
 
 today = date.today()
 nse = Nse()
@@ -13,19 +22,56 @@ all_stock_codes = nse.get_stock_codes()
 all_stock_names = dict(zip(nse.get_stock_codes().values(),nse.get_stock_codes().keys()))
 del all_stock_names['NAME OF COMPANY']
 
-st.set_page_config(page_title='Jarvis', page_icon='N', layout='wide', initial_sidebar_state='auto')
+st.set_page_config(page_title='Jarvis', page_icon=':money_with_wings:', layout='wide', initial_sidebar_state='auto')
+pd.options.plotting.backend = "plotly"
 st.title('Jarvis')
-stock_tab, mf_tab = st.tabs(['Stocks', 'Mutual Funds'])
+stock_tab, mf_tab, intraday_tab = st.tabs(['Stocks', 'Mutual Funds', 'Intraday'])
+
+main_sidebar = st.sidebar
+with main_sidebar:
+
+    vix_container = st.container()
+    with vix_container:
+
+        with st.spinner(text='Loading VIX Analysis...'):
+            try:
+                st.subheader("VIX Analysis")
+                vix_df = get_history(symbol="India VIX", start=today-timedelta(30), end=today, index=True)
+                vix_analysis_df = ProcessVixData(vix_df)
+                value = vix_analysis_df.Norm_Class[-30:].mean()
+                st.metric("Current Market Mood", GetMood(value), '{:.2f}'.format(value))
+                mood_dict = {'Greed': 'Markets are in bullish state. Good time to book profits.',
+                             'Holding Steady': 'Markets are indecisive. its good to hold onto existing portfolio.',
+                             'Fear': "Markets are in bearish state. Good time to pick good stocks for cheap prices."}
+
+                with st.expander(GetMood(value)):
+                    st.write(mood_dict[GetMood(value)])
+            except:
+                st.error("Issues fetching VIX Data!")
+
+    top_losers = st.container()
+    with top_losers:
+        if GetTopLosers() is not None:
+            st.subheader('Top Losers')
+            st.table(GetTopLosers())
+
+    top_gainers = st.container()
+    with top_gainers:
+        if GetTopGainers() is not None:
+            st.subheader('Top Gainers')
+            st.table(GetTopGainers())
 
 with stock_tab:
+    min_days = 60
     stock_selector_col, tenure_selector_start_col, tenure_selector_end_col = st.columns(3)
     with stock_selector_col:
         selected_stock = st.selectbox('Please select a stock for analysis',
-                                        list(all_stock_names.keys()),help='Choose stock to analyze')
+                                      list(all_stock_names.keys()),
+                                      help='Choose stock to analyze')
         ticker_yf = all_stock_names[selected_stock]+".NS"
 
     with tenure_selector_start_col:
-        start_date = st.date_input("Start Date", today-timedelta(40))
+        start_date = st.date_input("Start Date", today-timedelta(min_days))
 
     with tenure_selector_end_col:
         end_date = st.date_input("End Date", today)
@@ -34,8 +80,8 @@ with stock_tab:
         st.error('Start date should be before End date')
 
     time_delta = end_date-start_date
-    if time_delta.days < 35:
-        st.error('Please extend the range of dates. We need atleast 30 days of data for analysis.')
+    if time_delta.days < min_days:
+        st.error(f'Please extend the range of dates. We need atleast {min_days} days of data for analysis.')
 
     with st.spinner(text=f'Please Wait...Loading data for {selected_stock}'):
         tk = yf.Ticker(ticker_yf)
@@ -66,34 +112,180 @@ with stock_tab:
                                          close=stock_data_df['Close'])])
     st.plotly_chart(fig_main_cs, use_container_width=True)
 
+    st.markdown("***")
+
     st.subheader('Candlestick Matched pattern:')
-    pattern_expander_col, cs_gauge_col = st.columns((1,3))
+    pattern_expander_col, cs_gauge_col = st.columns((1, 1))
 
     matched_pattern, tech_df = GetPatternForData(stock_data_df=stock_data_df)
     if matched_pattern is not None:
         with pattern_expander_col:
             with st.expander(matched_pattern):
                 st.write("Will add description here")
+        with cs_gauge_col:
+            score_cs_pattern = tech_df[[matched_pattern]].astype(float).sum()[0]
+            if score_cs_pattern < 0:
+                value = "Bearish Outlook"
+                delta = -1
+            elif score_cs_pattern == 0:
+                value = "Indecisive Outlook"
+                delta = 0
+            else:
+                value = "Bullish Outlook"
+                delta = 1
 
+            st.metric(label='Pattern Verdict', value=value, delta=delta, help="Outlook from detected CandleStick pattern")
     else:
         with pattern_expander_col:
             with st.expander("No Pattern Matched"):
                 st.write("It seems there were no pattern formations for last 10 days.")
 
-with st.sidebar:
-    vix_container = st.container()
-    with vix_container:
-        st.subheader("VIX Analysis")
-        with st.spinner(text='Loading VIX Analysis...'):
-            vix_df = get_history(symbol="India VIX", start=today-timedelta(30), end=today, index=True)
-            vix_analysis_df = ProcessVixData(vix_df)
-        value = vix_analysis_df.Norm_Class[-30:].mean()
-        st.metric("Current Market Mood", GetMood(value), '{:.2f}'.format(value))
-        mood_dict = {'Greed': 'Markets are in bullish state. Good time to book profits.',
-                     'Holding Steady': 'Markets are indecisive. its good to hold onto existing portfolio.',
-                     'Fear': "Markets are in bearish state. Good time to pick good stocks for cheap prices."}
+        with cs_gauge_col:
+            st.metric(label='Pattern Verdict', value="Indecisive Outlook", delta=0,
+                      help="Outlook from detected CandleStick pattern")
+
+    st.markdown("***")
+    st.subheader('Volume Analysis Pattern:')
+    chaikin_curr_trend_col, MACD_curr_trend_col = st.columns(2)
+    with chaikin_curr_trend_col:
+        st.subheader("Chaikin Indicator")
+        chaikin_osc_df = ComputeChaikinADSignal(stock_data_df)
+        chaikin_osc_trend = chaikin_osc_df.ADOSC.iloc[-10:].mean()
+        chaikin_osc_trend_chg = chaikin_osc_df.ADOSC_chg.iloc[-10:].mean()
+
+        if chaikin_osc_trend >= 0:
+            chaikin_trend = "Bullish"
+        else:
+            chaikin_trend = "Bearish"
+
+            st.metric(label="Chaikin Current Trend", value=chaikin_trend,
+                      delta="{:.2f}%".format(chaikin_osc_trend_chg*100),
+                      help="Chaikin Oscillator is an indicator of buy/sell pressure in the market for give stock.")
+    with MACD_curr_trend_col:
+        st.subheader("MACD Indicator")
+        macd_df = ComputeMACDSignal(stock_data_df.set_index('Date'))
+        macd_bull_bear_signal = "Bullish" if macd_df.macd.iloc[-1] >= macd_df.macdsignal.iloc[-1] else "Bearish"
+        st.metric(label="MACD Signal", value=macd_bull_bear_signal, delta="{:.2f}".format(macd_df.macdhist.iloc[-1]),
+                  help="Helpful in analyzing momentum of price.")
+
+    momentum_plot_column = st.container()
+    st.subheader("MACD Chart")
+    with momentum_plot_column:
+        fig_macd = go.Figure()
+        fig_macd = make_subplots(rows=3, cols=1, shared_xaxes=True,
+                                 vertical_spacing=0.01, row_heights=[0.5, 0.3, 0.3])
+        fig_macd.add_trace(go.Candlestick(x=macd_df.index,
+                 open=macd_df['Open'],
+                 high=macd_df['High'],
+                 low=macd_df['Low'],
+                 close=macd_df['Close'], name=f"OHLC Chart : {ticker_yf}"), row=1, col=1)
+
+        colors = ['green' if row['Open'] - row['Close'] >= 0
+                  else 'red' for index, row in macd_df.iterrows()]
+        fig_macd.add_trace(go.Bar(x=macd_df.index, y=macd_df['Volume'], marker_color=colors, name="Volume"),
+                           row=2, col=1)
+        colors = ['green' if val >= 0
+                  else 'red' for val in macd_df.macdhist]
+        fig_macd.add_trace(go.Bar(x=macd_df.index, y=macd_df.macdhist, marker_color=colors, name="MACD Histogram"), row=3, col=1)
+        fig_macd.add_trace(go.Scatter(x=macd_df.index, y=macd_df.macd, line=dict(color='black', width=2), name="MACD"),
+                           row=3, col=1)
+        fig_macd.add_trace(go.Scatter(x=macd_df.index, y=macd_df.macdsignal,
+                                      line=dict(color='blue', width=1), name="MACD Signal"), row=3, col=1)
+        fig_macd.update_yaxes(title_text="Price", row=1, col=1)
+        fig_macd.update_yaxes(title_text="Volume", row=2, col=1)
+        fig_macd.update_yaxes(title_text="MACD", showgrid=False, row=3, col=1)
+        st.plotly_chart(fig_macd, use_container_width=True)
+
+
+
+with intraday_tab:
+
+    stock_selector_container_intraday = st.container()
+    stock_selector_container_intraday_placeholder = st.empty()
+    with stock_selector_container_intraday:
+        selected_stock_intraday_col, _, barrier_probability_calc_input_col, barrier_probability_calc_button_col \
+            = st.columns((1, 1, 1, 1))
+        with selected_stock_intraday_col:
+            selected_stock_intraday = st.selectbox(label='Select stock for intraday analysis',
+                                                   options=list(all_stock_names.keys()),
+                                                   help='Choose stock to analyze')
+        intraday_selected_ticker = all_stock_names[selected_stock_intraday]
+        stock_quote_intraday = nse.get_quote(intraday_selected_ticker)
+
+        with barrier_probability_calc_input_col:
+            barrier = st.number_input("Enter strike to calculate hit probability", min_value=1.0,
+                                      value=100.00, step=0.01, max_value=999999999.99,
+                                      help="Use this tool to estimate strike price of options strategy.")
+            if barrier < 0:
+                st.error("Please enter strike > 0.")
+        with barrier_probability_calc_button_col:
+            r = 0.073
+            tk = yf.Ticker(intraday_selected_ticker + ".NS")
+            v = np.log((tk.history(period='365d', interval="1d")['Close'] /
+                        tk.history(period='365d', interval="1d")['Close'].shift(1)).dropna()).std()
+            live_stock_price_intraday = nse.get_quote(intraday_selected_ticker)['lastPrice']
+            barrier_flag = 1 if barrier > live_stock_price_intraday else -1
+            T = 1
+            d2 = barrier_flag * ((log(live_stock_price_intraday / barrier) + (r - 0.5 * v ** 2)*T) / v*sqrt(T))
+            hit_prob = exp(-r) * norm.cdf(d2)
+            st.metric(label="Barrier hit probability", value='{:.0f}'.format(hit_prob*100) + '%',
+                      help="It gives probability that stock price will hit"
+                      " the strike price you entered")
+
+    while True:
+        with stock_selector_container_intraday_placeholder.container():
+            quote_dict = nse.get_quote(intraday_selected_ticker)
+            nifty_quote_dict = nse.get_index_quote('Nifty 50')
+            live_stock_col, live_nifty_col = st.columns(2)
+            with live_stock_col:
+                live_stock_price_intraday = quote_dict['lastPrice']
+                st.metric(label=all_stock_names[selected_stock_intraday], value=live_stock_price_intraday,
+                          delta=quote_dict['pChange'])
+            with live_nifty_col:
+                live_nifty_price = nifty_quote_dict['lastPrice']
+                st.metric(label="Nifty 50", value=live_nifty_price,
+                          delta=nifty_quote_dict['pChange'])
+
+            st.markdown("***")
+
+            tk = yf.Ticker(intraday_selected_ticker+'.NS')
+            df_intraday_realtime = tk.history(period='1d', interval='1m')
+            df_intraday_realtime['VWAP'] = (((df_intraday_realtime.High + df_intraday_realtime.Low
+                                              + df_intraday_realtime.Close) / 3)
+                                            * df_intraday_realtime.Volume).cumsum() /\
+                                           df_intraday_realtime.Volume.cumsum()
+            df_intraday_realtime.dropna(inplace=True)
+            fig = go.Figure()
+            fig.add_trace(go.Scatter(x=df_intraday_realtime.index, y=df_intraday_realtime.Close,
+                                     mode='lines',
+                                     name='Price'))
+            fig.add_trace(go.Scatter(x=df_intraday_realtime.index, y=df_intraday_realtime.VWAP,
+                                     mode='lines',
+                                     name='VWAP'))
+            fig.update_layout(title=intraday_selected_ticker, xaxis_title="Time",
+                              yaxis_title=intraday_selected_ticker+" Price")
+            st.plotly_chart(fig, use_container_width=True)
+
+            if df_intraday_realtime.Close.values[-1] < df_intraday_realtime.VWAP.values[-1]:
+                VWAP_signal = "Buy"
+                vwap_icon = ':thumbsup:'
+                vwap_explain = "Currently the market price is less than the VWAP price. Its good time to enter into trade."
+            elif df_intraday_realtime.Close.values[-1] == df_intraday_realtime.VWAP.values[-1]:
+                VWAP_signal = "Hold"
+                vwap_icon = ':open_hands:'
+                vwap_explain = "Currently the market price is equal to the VWAP price. Wait for buy or sell signal"
+            else:
+                VWAP_signal = "Sell"
+                vwap_icon = ':thumbsdown:'
+                vwap_explain = "Currently the market price is greater than the VWAP price. Its good time to exit the trade."
 
-        with st.expander(GetMood(value)):
-            st.write(mood_dict[GetMood(value)])
+            vwap_expander_col, _ = st.columns((1, 3))
+            with vwap_expander_col:
+                with st.expander(f"VWAP Buy/Sell Indicator : {VWAP_signal}"):
+                    st.markdown(vwap_explain)
+                st.header(vwap_icon)
 
+        time.sleep(5)
 
+with mf_tab:
+    st.write("Coming soon...")