implemented symbol getter, price candlestick, trend deviations from linear regressed prices, VWAP, bollinger bands, candle indicators and sector trends

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/finance.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="jdk" jdkName="Python 3.12" jdkType="Python SDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="Black">
+    <option name="sdkName" value="Python 3.12" />
+  </component>
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.12" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/finance.iml" filepath="$PROJECT_DIR$/.idea/finance.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

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

app.py

@@ -0,0 +1,8 @@
+import streamlit as st
+
+import page_symbol_details
+
+if __name__ == '__main__':
+    st.set_page_config(layout="wide")
+
+    page_symbol_details.run()

calculator.py

@@ -0,0 +1,55 @@
+import numpy as np
+from datetime import datetime
+
+
+def linear_regression_line(dates, y_list):
+    if not any(dates):
+        return 0, 0
+    if isinstance(dates[0], datetime):
+        dates = [ts.timestamp() for ts in dates]
+    if not isinstance(dates, np.ndarray):
+        dates = np.array(dates)
+    if not isinstance(y_list, np.ndarray):
+        y_list = np.array(y_list)
+
+    mean_x = np.mean(dates)
+    mean_y = np.mean(y_list)
+
+    # Calculate the slope (m) and y-intercept (c) of the regression line
+    m = np.sum((dates - mean_x) * (y_list - mean_y)) / np.sum((dates - mean_x) ** 2)
+    c = mean_y - m * mean_x
+
+    return m, c
+
+
+def linear_regression_points(dates, y_list):
+    if not any(dates):
+        return 0, 0
+    if isinstance(dates[0], datetime):
+        dates = [ts.timestamp() for ts in dates]
+    if not isinstance(dates, np.ndarray):
+        dates = np.array(dates)
+    if not isinstance(y_list, np.ndarray):
+        y_list = np.array(y_list)
+
+    m, c = linear_regression_line(dates, y_list)
+
+    return m * dates + c
+
+
+def linear_regression(dates, y_list):
+    if not any(dates):
+        return 0, 0
+    if isinstance(dates[0], datetime):
+        dates = [ts.timestamp() for ts in dates]
+    if not isinstance(dates, np.ndarray):
+        dates = np.array(dates)
+    if not isinstance(y_list, np.ndarray):
+        y_list = np.array(y_list)
+
+    m, c = linear_regression_line(dates, y_list)
+
+    y_low = m * dates[0] + c
+    y_high = m * dates[-1] + c
+
+    return y_low, y_high

data_retriever.py

@@ -0,0 +1,102 @@
+import yfinance as yf
+import finnhub
+
+import os
+from datetime import date, datetime, timedelta
+from collections import defaultdict
+
+import static_data
+
+#test
+import streamlit as st
+
+
+@st.cache_data
+def get_exchange_code_names():
+    return static_data.exchange_code_names
+
+
+@st.cache_data
+def get_exchange_codes():
+    return static_data.exchange_codes
+
+
+@st.cache_data
+def get_symbols(exchange_code):
+    symbol_data = finnhub_client().stock_symbols(exchange_code)
+    symbols = []
+    for symbol_info in symbol_data:
+        symbols.append(symbol_info['displaySymbol'])
+    symbols.sort()
+    return symbols
+
+
+@st.cache_data
+def today():
+    return date.today().strftime("%Y-%m-%d")
+
+
+def n_weeks_before(date_string, n):
+    date_value = datetime.strptime(date_string, "%Y-%m-%d") - timedelta(days=7*n)
+    return date_value.strftime("%Y-%m-%d")
+
+
+def n_days_before(date_string, n):
+    date_value = datetime.strptime(date_string, "%Y-%m-%d") - timedelta(days=n)
+    return date_value.strftime("%Y-%m-%d")
+
+@st.cache_data
+def get_current_stock_data(symbol, n_weeks):
+    current_date = today()
+    n_weeks_before_date = n_weeks_before(current_date, n_weeks)
+    stock_data = yf.download(symbol, n_weeks_before_date, current_date)
+    return stock_data
+
+
+@st.cache_data
+def finnhub_client():
+    return finnhub.Client(api_key=os.environ["FINNHUB_API_KEY"])
+
+
+@st.cache_data
+def get_current_basics(symbol, day):
+    basic_financials = finnhub_client().company_basic_financials(symbol, 'all')
+    if not basic_financials['series']:
+        return []
+
+    basic_list, basic_dict = [], defaultdict(dict)
+
+    for metric, value_list in basic_financials['series']['quarterly'].items():
+        for value in value_list:
+            basic_dict[value['period']].update({metric: value['v']})
+
+    for k, v in basic_dict.items():
+        v.update({'period': k})
+        basic_list.append(v)
+
+    basic_list.sort(key=lambda x: x['period'])
+
+    for basic in basic_list[::-1]:
+        if basic['period'] <= day:
+            return basic
+
+    return basic_list[-1]
+
+
+@st.cache_data
+def get_peers(symbol):
+    return finnhub_client().company_peers(symbol)
+
+
+@st.cache_data
+def get_financials(symbol, freq):
+    return finnhub_client().financials_reported(symbol=symbol, freq=freq)
+
+
+@st.cache_data
+def get_income_statement(symbol, freq='quarterly'):
+    financials = get_financials(symbol, freq)
+    financials_data = financials['data']
+    dates = [financials_data['endDate'] for financials_data in financials_data]
+    ic = [financials_data['report']['ic'] for financials_data in financials_data]
+    return dates, ic

indicators.py

@@ -0,0 +1,102 @@
+# Defines candlestick indicators, and creates data-points for a dataset when an indicator is detected.
+
+import streamlit as st
+from collections import defaultdict
+
+
+def price_at_index(index, dates, dataset):
+    price = defaultdict(float)
+
+    opens = dataset['Open']
+    closes = dataset['Close']
+    highs = dataset['High']
+    lows = dataset['Low']
+
+    price['Date'] = dates[index]
+    price['Open'] = opens[index]
+    price['Close'] = closes[index]
+    price['High'] = highs[index]
+    price['Low'] = lows[index]
+    return price
+
+
+def candle_is_green(current_price):
+    return current_price['Open'] < current_price['Close']
+
+
+def engulfing_candle(prev_price, current_price):
+    prev_is_green = candle_is_green(prev_price)
+    current_is_green = candle_is_green(current_price)
+    from_negative_to_positive = not prev_is_green and current_is_green
+    from_positive_to_negative = prev_is_green and not current_is_green
+    is_bullish_engulfing = from_negative_to_positive and current_price['Close'] > prev_price['Open'] and current_price['Open'] < prev_price['Close']
+    is_bearish_engulfing = from_positive_to_negative and current_price['Close'] < prev_price['Open'] and current_price['Open'] > prev_price['Close']
+    return is_bullish_engulfing, is_bearish_engulfing
+
+
+def engulfing_candle_bullish(prev_price, current_price):
+    prev_is_green = candle_is_green(prev_price)
+    current_is_green = candle_is_green(current_price)
+    from_negative_to_positive = not prev_is_green and current_is_green
+    is_bullish_engulfing = from_negative_to_positive and current_price['Close'] > prev_price['Open'] and current_price['Open'] < prev_price['Close']
+    return is_bullish_engulfing
+
+
+def engulfing_candle_bearish(prev_price, current_price):
+    prev_is_green = candle_is_green(prev_price)
+    current_is_green = candle_is_green(current_price)
+    from_positive_to_negative = prev_is_green and not current_is_green
+    is_bearish_engulfing = from_positive_to_negative and current_price['Close'] < prev_price['Open'] and current_price['Open'] > prev_price['Close']
+    return is_bearish_engulfing
+
+
+def create_engulfing_candle_bullish_indicators(dates, dataset):
+    indicator = defaultdict(list)
+    indicator_timestamps = indicator['Date']
+    indicator_values = indicator['Values']
+    
+    prev_price = price_at_index(0, dates, dataset)
+    for index in range(1, len(dates)):
+        price = price_at_index(index, dates, dataset)
+        is_engulfing = engulfing_candle_bullish(prev_price, price)
+        if is_engulfing:
+            indicator_timestamps.append(dates[index])
+            offset = ((price['Close'] - price['Open']) - (prev_price['Open'] - prev_price['Close'])) * 5
+            value = price['Close'] + offset
+            indicator_values.append(value)
+        prev_price = price
+
+    indicator_dict = dict(indicator)
+    indicator_dict['IsBullish'] = True
+
+    return indicator_dict
+
+
+def create_engulfing_candle_bearish_indicators(dates, dataset):
+    indicator = defaultdict(list)
+    indicator_timestamps = indicator['Date']
+    indicator_values = indicator['Values']
+    
+    prev_price = price_at_index(0, dates, dataset)
+    for index in range(1, len(dates)):
+        price = price_at_index(index, dates, dataset)
+        is_engulfing = engulfing_candle_bearish(prev_price, price)
+        if is_engulfing:
+            indicator_timestamps.append(dates[index])
+            offset = ((price['Open'] - price['Close']) - (prev_price['Close'] - prev_price['Open'])) * 5
+            value = price['Close'] - offset
+            indicator_values.append(value)
+        prev_price = price
+
+    indicator_dict = dict(indicator)
+    indicator_dict['IsBullish'] = False 
+
+    return indicator_dict
+
+
+def create_indicators(dates, dataset):
+    indicators = defaultdict(dict)
+    indicators['Engulfing Bullish'] = create_engulfing_candle_bullish_indicators(dates, dataset)
+    indicators['Engulfing Bearish'] = create_engulfing_candle_bearish_indicators(dates, dataset)
+    return indicators
+

page_symbol_details.py

@@ -0,0 +1,86 @@
+import numpy as np
+import streamlit as st
+from plotly.subplots import make_subplots
+
+import data_retriever
+import trends
+import ui
+
+
+def run():
+    exchange_names = data_retriever.get_exchange_code_names()
+    exchanges_selectbox = st.selectbox(
+        'Exchange:',
+        exchange_names,
+        index=exchange_names.index('US exchanges (NYSE, Nasdaq)')
+    )
+    exchange_name = exchanges_selectbox
+    exchange_index = exchange_names.index(exchange_name)
+    exchange = data_retriever.get_exchange_codes()[exchange_index]
+
+    symbols = data_retriever.get_symbols(exchange)
+    symbols_selectbox = st.selectbox(
+        'Stock:',
+        symbols, 
+        index=symbols.index('AAPL')
+    )
+    symbol = symbols_selectbox
+
+    # max time period
+    st.text_input("No. of years look-back", value=1, key="years_back")
+    years_back = int(st.session_state.years_back)
+    weeks_back = years_back*12*4
+
+    symbol_prices = data_retriever.get_current_stock_data(symbol, weeks_back)
+    if not any(symbol_prices):
+        return
+    dates = symbol_prices.index.format()
+
+    # back test
+    st.text_input('No. of days back-test', value=0, key="backtest_period")
+    n_days_back = int(st.session_state.backtest_period)
+    end_date = data_retriever.n_days_before(data_retriever.today(), n_days_back)
+    symbol_prices_backtest = symbol_prices[symbol_prices.index <= end_date]
+    backtest_dates = symbol_prices_backtest.index.format()
+
+    # symbol candlestick graph
+    candleFigure = make_subplots(rows=1, cols=1)
+    ui.create_candlestick(candleFigure, dates, symbol_prices, symbol, 'Price')
+    # # indicators
+    # indicator_datasets = indicators.create_indicators(dates, symbol_prices)
+    # ui.create_indicators(fig1, indicator_datasets)
+    # trend lines
+    sigma_multiplier = st.slider(label='min trend deviation', min_value=1.0, max_value=10.0, value=3.0, step=0.1)
+    sigma_dates, sigma_values = trends.trend_line(symbol_prices_backtest.index, np.array(symbol_prices_backtest['Close']), min_trend_size=21, sigma_multiplier=sigma_multiplier)
+    ui.create_markers(candleFigure, sigma_dates, sigma_values, f"{sigma_multiplier} Deviations from regression line", 'Deviations')
+
+    # vwap
+    vwap = trends.vwap(symbol_prices_backtest)
+    ui.create_line(candleFigure, backtest_dates, vwap, "Volume Weighted Average Price (VWAP)", "VWAP")
+
+    # bollinger bands
+    bollinger_dates, bollinger_low, bollinger_high = trends.bollinger_bands(backtest_dates, symbol_prices_backtest)
+    ui.create_fill_area(candleFigure, bollinger_dates, bollinger_low, bollinger_high, "Bollinger Bands")
+
+    # plot all
+    candleFigure.update_layout(title="Symbol Ticker",
+                               xaxis_title='Date',
+                               yaxis_title="Price per Share",
+                               template='plotly_dark')
+    candle_chart_id = st.plotly_chart(candleFigure, use_container_width=True, key='candle')
+
+    if st.checkbox('Sector Trends'):
+        # plot the trend of the market as a candlestick graph.
+        fig2 = make_subplots(rows=1, cols=1)
+        dates, close_data, relative_close_data, sector_normalized_avg = trends.sector_trends(symbol, weeks_back)
+        ui.create_candlestick(fig2, dates, sector_normalized_avg, 'Sector Trend', 'Normalized Price')
+        st.plotly_chart(fig2, use_container_width=True)
+
+        # plot the difference between each peer and the sector trend
+        fig3 = make_subplots(rows=1, cols=1)
+        ui.create_lines(fig3, dates, relative_close_data, "Peer 'Close' Relative to Sector", 'Relative Close')
+        st.plotly_chart(fig3, use_container_width=True)
+
+    if st.checkbox('Symbol Basics'):
+        basics_data = data_retriever.get_current_basics(symbol, data_retriever.today())
+        st.write(basics_data)

requirements.txt

@@ -0,0 +1,11 @@
+streamlit
+
+yfinance
+finnhub-python
+
+pandas
+datetime
+
+plotly
+
+numpy

static_data.py

@@ -0,0 +1,163 @@
+exchange_code_names = ['ABU DHABI SECURITIES EXCHANGE',
+'Aquis Exchange',
+'NYSE EURONEXT - EURONEXT AMSTERDAM',
+'ATHENS EXCHANGE S.A. CASH MARKET',
+'ASX - ALL MARKETS',
+'BOLSA DE COMERCIO DE BUENOS AIRES',
+'BOLSA DE VALORES DE COLOMBIA',
+'BUDAPEST STOCK EXCHANGE',
+'BOERSE BERLIN',
+'BAHRAIN BOURSE',
+'STOCK EXCHANGE OF THAILAND',
+'BSE LTD',
+'NYSE EURONEXT - EURONEXT BRUSSELS',
+'Egyptian Stock Exchange',
+'CANADIAN NATIONAL STOCK EXCHANGE',
+'OMX NORDIC EXCHANGE COPENHAGEN A/S',
+'CARACAS STOCK EXCHANGE',
+'CASABLANCA STOCK EXCHANGE',
+'DUBAI FINANCIAL MARKET',
+'XETRA',
+'Dhaka Stock Exchange',
+'BOERSE DUESSELDORF',
+'DEUTSCHE BOERSE AG',
+'NASDAQ OMX HELSINKI LTD',
+'HONG KONG EXCHANGES AND CLEARING LTD',
+'HANSEATISCHE WERTPAPIERBOERSE HAMBURG',
+'NASDAQ OMX ICELAND',
+'IRISH STOCK EXCHANGE - ALL MARKET',
+'BORSA ISTANBUL',
+'INDONESIA STOCK EXCHANGE',
+'JOHANNESBURG STOCK EXCHANGE',
+'BURSA MALAYSIA',
+'KOREA EXCHANGE (KOSDAQ)',
+'KOREA EXCHANGE (STOCK MARKET)',
+'Kuwait Stock Exchange',
+'LONDON STOCK EXCHANGE',
+'Euronext London',
+'NYSE EURONEXT - EURONEXT LISBON',
+'BOLSA DE MADRID',
+'MOSCOW EXCHANGE',
+'Italian Stock Exchange',
+'BOERSE MUENCHEN',
+'BOLSA MEXICANA DE VALORES (MEXICAN STOCK EXCHANGE)',
+'AEQUITAS NEO EXCHANGE',
+'Nigerian Stock Exchange',
+'NATIONAL STOCK EXCHANGE OF INDIA',
+'NEW ZEALAND EXCHANGE LTD',
+'OSLO BORS ASA',
+'NYSE EURONEXT - MARCHE LIBRE PARIS',
+'Philippine Stock Exchange',
+'PRAGUE STOCK EXCHANGE',
+'QATAR EXCHANGE',
+'NASDAQ OMX RIGA',
+'Brazil Bolsa - Sao Paolo',
+'BOERSE STUTTGART',
+'SINGAPORE EXCHANGE',
+'SANTIAGO STOCK EXCHANGE',
+'SAUDI STOCK EXCHANGE',
+'SHANGHAI STOCK EXCHANGE',
+'NASDAQ OMX NORDIC STOCKHOLM',
+'SWISS EXCHANGE',
+'SHENZHEN STOCK EXCHANGE',
+'TOKYO STOCK EXCHANGE-TOKYO PRO MARKET',
+'TEL AVIV STOCK EXCHANGE',
+'NASDAQ OMX TALLINN',
+'TORONTO STOCK EXCHANGE',
+'TAIWAN STOCK EXCHANGE',
+'TPEx',
+'Turquoise',
+'US exchanges (NYSE, Nasdaq)',
+'TSX VENTURE EXCHANGE - NEX',
+'Vienna Stock Exchange',
+'Vietnam exchanges including HOSE, HNX and UPCOM',
+'NASDAQ OMX VILNIUS',
+'WARSAW STOCK EXCHANGE/EQUITIES/MAIN MARKET',
+'CBOE Australia',
+'Hanover Stock Exchange',
+'DEUTSCHE BOERSE Stoxx',
+'DEUTSCHE BOERSE TradeGate',
+'BOERSE_FRANKFURT_ZERTIFIKATE',
+'Spotlight Stock Market']
+
+exchange_codes = ['AD'
+,'AQ'
+,'AS'
+,'AT'
+,'AX'
+,'BA'
+,'BC'
+,'BD'
+,'BE'
+,'BH'
+,'BK'
+,'BO'
+,'BR'
+,'CA'
+,'CN'
+,'CO'
+,'CR'
+,'CS'
+,'DB'
+,'DE'
+,'DS'
+,'DU'
+,'F'
+,'HE'
+,'HK'
+,'HM'
+,'IC'
+,'IR'
+,'IS'
+,'JK'
+,'JO'
+,'KL'
+,'KQ'
+,'KS'
+,'KW'
+,'L'
+,'LN'
+,'LS'
+,'MC'
+,'ME'
+,'MI'
+,'MU'
+,'MX'
+,'NE'
+,'NL'
+,'NS'
+,'NZ'
+,'OL'
+,'PA'
+,'PM'
+,'PR'
+,'QA'
+,'RG'
+,'SA'
+,'SG'
+,'SI'
+,'SN'
+,'SR'
+,'SS'
+,'ST'
+,'SW'
+,'SZ'
+,'T'
+,'TA'
+,'TL'
+,'TO'
+,'TW'
+,'TWO'
+,'TU'
+,'US'
+,'V'
+,'VI'
+,'VN'
+,'VS'
+,'WA'
+,'XA'
+,'HA'
+,'SX'
+,'TG'
+,'SC'
+,'SL']

trends.py

@@ -0,0 +1,140 @@
+from collections import defaultdict
+
+import numpy as np
+
+import calculator
+import data_retriever
+
+import streamlit as st
+
+
+# plot the trend of the market as a candlestick graph.
+def sector_trends(symbol, weeks_back):
+    # 1. get all peers
+    peers = data_retriever.get_peers(symbol)
+    # 2. get data for each peer
+    peers_stock_data = defaultdict(list)
+    dates = []
+    for peer in peers:
+        peer_data = data_retriever.get_current_stock_data(peer, weeks_back)
+        if len(peer_data) == 0:
+            continue
+        if not any(dates):
+            dates = peer_data.index.format()
+        peers_stock_data[peer] = peer_data
+
+    # 3. normalize all data (get min->max value, then set each value to (X-min)/(max-min)
+    peers_stock_data_normalized = defaultdict(dict)
+    indicator_stock_data_normalized_peer_sum = defaultdict(list)
+    for peer, peer_stock_data in peers_stock_data.items():
+        peer_stock_data_normalized = defaultdict(list)
+        for indicator in peer_stock_data:
+            indicator_normalized = peer_stock_data_normalized[indicator]
+            indicator_stock_data_normalized_sum = indicator_stock_data_normalized_peer_sum[indicator]
+
+            indicator_values = peer_stock_data[indicator]
+            min_val = indicator_values[0]
+            max_val = indicator_values[0]
+            for value in indicator_values:
+                if value < min_val:
+                    min_val = value
+                if value > max_val:
+                    max_val = value
+            delta = max_val - min_val
+
+            value_idx = 0
+            for value in indicator_values:
+                normalized = (value - min_val)/delta
+                indicator_normalized.append(normalized)
+
+                while len(indicator_stock_data_normalized_sum) <= value_idx:
+                    indicator_stock_data_normalized_sum.append(0)
+                indicator_stock_data_normalized_sum[value_idx] += normalized
+                value_idx += 1
+
+        peers_stock_data_normalized[peer] = peer_stock_data_normalized
+    # 4. get the average value for each indicator [open, close, high, low] for each time-step.
+    peer_count = len(peers)
+    indicator_stock_data_normalized_peer_avg = defaultdict(list)
+    for indicator, indicator_sum_values in indicator_stock_data_normalized_peer_sum.items():
+        indicator_avg_values = indicator_stock_data_normalized_peer_avg[indicator]
+        for sum_value in indicator_sum_values:
+            indicator_avg_values.append(sum_value/peer_count)
+    # 5. plot the resulting normalized-averaged-indicators in a candlestick chart.  
+    close_data = defaultdict(list)
+    for peer, peer_data_normalized in peers_stock_data_normalized.items():
+        close_data[peer] = peer_data_normalized['Close']
+    
+    relative_close_data = defaultdict(list)
+    for peer in peers_stock_data_normalized:
+        relative_close_data[peer] = [a - b for a, b in zip(close_data[peer], indicator_stock_data_normalized_peer_avg['Close'])]
+
+    return dates, close_data, relative_close_data, indicator_stock_data_normalized_peer_avg
+
+
+def trend_line(date_indices, data_list, min_trend_size=7, step_size=1, sigma_multiplier=1):
+    trend_dates, trend_values = [], []
+    if not any(date_indices) or not any(data_list):
+        return trend_dates, trend_values
+
+    np_dates = np.array([ts.timestamp() for ts in date_indices])
+    dates = date_indices.format()
+
+    start_index = 0
+    index = min_trend_size
+
+    while index < len(data_list):
+        np_dates_subset = np_dates[start_index:index]
+        np_values_subset = data_list[start_index:index]
+        # for the value range, calculate linear_regression and standard deviation
+        m, c = calculator.linear_regression_line(np_dates_subset, np_values_subset)
+        predicted_points = m * np_dates_subset + c
+        relative_mean = np.mean(np.abs(predicted_points - np_values_subset))  # TODO: use Welford's algorithm
+
+        # for the next datapoint(s), calculate the next value in that trend,
+        # and check if it is n*trend_sigma away from the current trend line
+        next_index = index + step_size
+        if next_index >= len(data_list):
+            break
+
+        x = np_dates[next_index:next_index+1]
+        y = data_list[next_index:next_index+1]
+        expected_y = m*x + c
+        dev = np.mean(np.abs(y - expected_y))
+
+        if dev > relative_mean * sigma_multiplier:
+            # store the current date and value as a trend changer
+            trend_dates.append(dates[index])
+            trend_values.append(data_list[index])
+            # reset the calculation for the next data
+            start_index = next_index - min_trend_size
+
+        index = next_index
+
+    return trend_dates, trend_values
+
+
+def vwap(symbol_price_data):
+    typical_price = (symbol_price_data['High'] + symbol_price_data['Low'] + symbol_price_data['Close']) / 3.0
+    volume = symbol_price_data['Volume']
+    vwap_values = (typical_price * volume).cumsum() / volume.cumsum()
+    return vwap_values
+
+
+def bollinger_bands(dates, symbol_price_data, n_days_deviation=20, deviation_multiplier=2):
+    bollinger_dates, bollinger_high, bollinger_low = [], [], []
+    closes = symbol_price_data['Close']
+
+    for index in range(0, len(closes) - n_days_deviation):
+        bollinger_dates.append(dates[index + n_days_deviation])
+
+        closes_subset = closes[index:index + n_days_deviation]
+        sma = np.sum(closes_subset)/len(closes_subset)
+        sigma = deviation_multiplier * np.sqrt(np.sum(np.power(closes_subset - sma, 2))/len(closes_subset))
+        bollinger_high.append(sma + sigma)
+        bollinger_low.append(sma - sigma)
+    return bollinger_dates, bollinger_low, bollinger_high
+
+
+def support_lines():
+    a = 1

ui.py

@@ -0,0 +1,97 @@
+import streamlit as st
+
+import plotly.graph_objects as go
+from plotly.validators.scatter.marker import SymbolValidator
+from plotly.subplots import make_subplots
+
+# chart datapoint icons
+raw_symbols = SymbolValidator().values
+up_arrow = raw_symbols[5]
+down_arrow = raw_symbols[6]
+
+
+def create_candlestick(fig, dates, dataset, title, y_label):
+    candlestick = go.Candlestick(name=y_label, 
+                                 x=dates,
+                                 open=dataset['Open'],
+                                 high=dataset['High'],
+                                 low=dataset['Low'],
+                                 close=dataset['Close'])
+    fig.add_trace(candlestick)
+    fig.update_xaxes(
+        rangeslider_visible=True,
+        rangeselector=dict(
+            buttons=list([
+                dict(count=1, label="1m", step="month", stepmode="backward"),
+                dict(count=6, label="6m", step="month", stepmode="backward"),
+                dict(count=1, label="YTD", step="year", stepmode="todate"),
+                dict(count=1, label="1y", step="year", stepmode="backward"),
+                dict(step="all")
+            ])
+        )
+    )
+
+
+def create_indicators(fig, datasets):
+    for indicator in datasets:
+        indicator_data = datasets[indicator]
+
+        marker_color="lightskyblue"
+        marker_symbol = 0
+        if 'IsBullish' in indicator_data:
+            if indicator_data['IsBullish']:
+                marker_color = 'green'
+                marker_symbol = 5
+            else:
+                marker_color = 'red'
+                marker_symbol = 6
+
+        indicator_plot = go.Scatter(name=indicator,
+                                    mode="markers",
+                                    x=indicator_data['Date'],
+                                    y=indicator_data['Values'],
+                                    marker_symbol=marker_symbol,
+                                    marker_line_color="midnightblue",
+                                    marker_color=marker_color,
+                                    marker_line_width=2,
+                                    marker_size=15,
+                                    hovertemplate="%{indicator}: %{y}%{x}<br>number: %{marker.symbol}<extra></extra>")
+        fig.add_trace(indicator_plot)
+
+
+def create_lines(fig, dates, datasets, title, y_label):
+    for key in datasets:
+        line = go.Scatter(name=key, x=dates, y=datasets[key])
+        fig.add_trace(line)
+
+
+def create_markers(fig, dates, dataset, title, y_label, marker_symbol=3, marker_color="blue", marker_size=15):
+    line = go.Scatter(name=title, x=dates, y=dataset,
+                      mode="markers",
+                      marker_symbol=marker_symbol,
+                      marker_line_color="midnightblue",
+                      marker_color=marker_color,
+                      marker_line_width=2,
+                      marker_size=marker_size)
+    fig.add_trace(line)
+
+
+def create_line(fig, dates, dataset, title, y_label, marker_symbol=4, marker_size=15):
+    line = go.Scatter(name=title, x=dates, y=dataset, marker_line_color="yellow")
+    fig.add_trace(line)
+
+
+def create_fill_area(fig, dates, y_low, y_high, title, color='rgba(0,100,80,0.2)'):
+    # line_low = go.Scatter(name=title, x=dates, y=y_low, fillcolor=color, showlegend=False)
+    # fig.add_trace(line_low)
+    # line_high = go.Scatter(name=title, x=dates, y=y_low, fillcolor=color, showlegend=False)
+    # fig.add_trace(line_high)
+    fill_area = go.Scatter(
+        name=title,
+        x=dates + dates[::-1],
+        y=y_high + y_low[::-1],
+        fill='toself',
+        fillcolor=color,
+        line=dict(color=color)
+    )
+    fig.add_trace(fill_area)