Create performance.py

performance.py

@@ -0,0 +1,472 @@
+'''
+Example 8 for using yfinance
+
+Calculate annual, trailing, cumumlative, and CAGR returns for multiple stocks.
+* The start date can be an arbitrary date.  The default is the current date.
+* annual return is displayed from the default current day, or an arbitrary given
+  day (except for Feb 29 for leap year) TODO-fix
+* trailing, cumumlative returns are currently displayed from the month boundary (last day of Month)
+  prior to the given date.
+* However, trailing, cumumlative returns can be displayed
+  from any date, which can be not at the month boundary (last day of Month),
+  by minor change of setting calculation_end_date_for_others_str = calculation_end_date_str.
+  prior to the given date in the function "calculation_response(message, history)"
+
+Author: Gang Luo
+'''
+script_version = '(2024-01-24.2)'
+import gradio as gr
+import yfinance as yf
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+import pytz
+#==============================================================================
+
+print_yearly_total_return = True
+num_years_calculation=32   # total years for calculation
+
+# Define a list of years to calculate the trailing returns, cumulative returns, and so on
+# remove the row of current year row since it is not a full year.
+years_list = [1, 2, 3, 5, 10, 15, 20, 25, 30]
+
+# Set the stock tickers list
+tickers_lists = [["spy", "vfv.to","xiu.to"], #0
+    ["spy", "vfv.to", "vgg.to", "zlu.to", "xiu.to", "vdy.to", "xfn.to", "ry.to", "td.to", "na.to",
+      "slf.to", "gwo.to", "bce.to", "t.to", "rci-b.to", "enb.to", "trp.to", "zlb.to", "cp.to"], #1
+    ["spy","vfv.to", "xiu.to", "zeb.to", "xfn.to", "na.to","ry.to", "bmo.to","bns.to", "td.to", "cm.to", "cwb.to",
+      "slf.to", "gwo.to", "bce.to", "t.to", "rci-b.to", "enb.to", "trp.to", "xdv.to","cdz.to","vdy.to"],  #2
+    ["spy", "vfv.to", "vgg.to", "zlu.to","goog", "msft", "meta", "tsla","AMZN", "AAPL", "shop.to"],   #3
+    ["^IXIC","qqq","hxq.to","^GSPC","spy","voo","ivv", "vfv.to", "zsp.to","xus.to", "xsp.to","^GSPTSE","xic.to","xiu.to","xfn.to", "fie.to"], #4
+    ["^IXIC","ONEQ","CIBR","QQJG", "qqq", "spy", "vfv.to", "HXQ.to", "ZQQ.to", "XQQ.to", "QQC.to"]  #5
+]
+
+#==============================================================================
+# Part 1: fetch retrieve yearly total returns by yfinance & display
+# Function to fetch data from yfinance and extract yearly total returns#
+# annual return calculation can start at any given day
+def get_annual_returns_df(ticker, calculation_end_date_str):
+    # Get the historical data for the given ticker
+    stock = yf.Ticker(ticker)
+    calculation_end_date=pd.to_datetime(calculation_end_date_str).tz_localize('America/New_York')
+    try:
+        '''
+        'try' statement for handlingy the exception error of stock.history that a ticker is not yet at stock market,
+        For example, "shop.to" is not there in 2012
+        '''
+        stock_history=stock.history(period="max")["Close"]
+        '''
+        Between the start and end days in stock_history variable, there are some missing days where there are no corresponding rows.
+        Add rows of  missing  days such that the values of column "Close" are set to be the value of the closest earlier day's
+        value, by using date_range to create full range without any missing date.
+        '''
+        # Create a DataFrame with a complete date range
+        date_range = pd.date_range(start=stock_history.index.min(), end=stock_history.index.max(), freq='D')
+        complete_stock_history = pd.DataFrame(index=date_range)
+        # Merge the complete DataFrame with the original stock_history
+        complete_stock_history = complete_stock_history.merge(stock_history, how='left', left_index=True, right_index=True)
+        complete_stock_history['Close'] = complete_stock_history['Close'].ffill()  # fill the newy added rows with previous day value
+        '''
+        Filter out the rows that matches the month and date of calculation_end_date, which are the ends of
+        annual periods from the calculation_end_date.
+        '''
+        # Filter out rows with dates newer than calculation_end_date
+        filtered_stock_history = complete_stock_history[complete_stock_history.index <= calculation_end_date]
+        #print(filtered_stock_history)
+        target_month=filtered_stock_history.index.max().month
+        target_day=filtered_stock_history.index.max().day
+        #print("target_month", target_month, "target_day",target_day, "start_year", filtered_stock_history.index.max().year)
+        annual_returns = filtered_stock_history[(filtered_stock_history.index.month == target_month)
+           & (filtered_stock_history.index.day ==target_day)]
+        annual_returns_percent = annual_returns.pct_change().dropna()
+    except:
+        return  pd.DataFrame()
+    else:
+        annual_returns_df = pd.DataFrame(annual_returns_percent, columns=['Close'])
+        annual_returns_df.rename(columns={'Close': ticker}, inplace=True)
+        return annual_returns_df
+
+# Function to fetch data from yfinance and extract yearly total returns
+# annual return calculation starts at only yaer end boundary, i.e, Dec 31,
+# by resample('A')
+def get_annual_returns_year_boundary_df(ticker, calculation_end_date_str):
+    # Get the historical data for the given ticker
+    stock = yf.Ticker(ticker)
+    calculation_end_date = datetime.strptime(calculation_end_date_str, "%Y-%m-%d")
+    calculation_start_date_str = (calculation_end_date
+                - timedelta(days=num_years_calculation * 365)).strftime("%Y-%m-%d")
+
+    try:
+        '''
+        1.  'try' statement for handlingy the exception error of stock.history that a ticker is not yet at stock market,
+             For example, "shop.to" is not there in 2012
+        2. The row with the latest day from .history(.., end='end_day_date') is the day prior to end_day_date.  Therefore,
+           let end=the expected end day plus one day.
+        '''
+        calculation_end_date_plus_1day_str =  (calculation_end_date + timedelta(days=1)).strftime("%Y-%m-%d")
+        annual_returns_history=stock.history(start=calculation_start_date_str,end=calculation_end_date_plus_1day_str)["Close"]
+
+        #print("debug get_annual_returns_df ", ticker, annual_returns_history)
+        # For 'A', 'Y', see https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases
+        ffilled_history=annual_returns = annual_returns_history.resample('A').ffill()
+        #print(ffilled_history)
+        annual_returns = ffilled_history.pct_change().dropna()
+        #annual_returns = annual_returns_history.resample('A').ffill().pct_change().dropna()
+        #print("debug get_annual_returns_df after resample()", ticker, calculation_end_date, "\n", annual_returns)
+    except:
+        return  pd.DataFrame()
+    else:
+        annual_returns_df = pd.DataFrame(annual_returns, columns=['Close'])
+        annual_returns_df.rename(columns={'Close': ticker}, inplace=True)
+        return annual_returns_df
+
+#----------------------------------------------------------------------------------
+# handling a list of tickers by calling the functions (either get_annual_returns_df
+# get_annual_returns_year_boundary_df) that handle single tickers
+def get_annual_returns_tickers_common_df(tickers, calculation_end_date_str, annual_returns_func_df):
+    # Create an empty DataFrame to store all tickers' total returns
+    all_tickers_returns_df = pd.DataFrame()
+
+    # Loop through each ticker in the list
+    for ticker in tickers:
+        ticker_returns_df = annual_returns_func_df(ticker, calculation_end_date_str)
+        if not ticker_returns_df.empty:
+            if all_tickers_returns_df.empty:
+                all_tickers_returns_df = ticker_returns_df
+            else:
+                all_tickers_returns_df = pd.concat([all_tickers_returns_df, ticker_returns_df], axis=1)  # Concatenate DataFrames
+        else:
+            # New column with NaN values
+            new_column_name = ticker
+            new_column_values = [None] * len(all_tickers_returns_df)
+            new_column = pd.DataFrame({new_column_name: new_column_values}, index=all_tickers_returns_df.index)
+            # Concatenate the new column to the original DataFrame
+            all_tickers_returns_df = pd.concat([all_tickers_returns_df, new_column], axis=1)
+    #return date_label_conversion_strip_time(all_tickers_returns_df, calculation_end_date_str)
+    return all_tickers_returns_df
+
+def get_annual_returns_tickers_df(tickers, calculation_end_date_str):
+    return get_annual_returns_tickers_common_df(tickers, calculation_end_date_str,
+                                                get_annual_returns_df)
+
+def get_annual_returns_tickers_year_boundary_df(tickers, calculation_end_date_str):
+    return get_annual_returns_tickers_common_df(tickers, calculation_end_date_str,
+                                                get_annual_returns_year_boundary_df)
+
+#==============================================================================
+# Part 2: calculate the annualized trailing total return from the data generated in step 1 & display
+# Define a function to calculate the annualized trailing total return for a given number of years
+def get_trailing_return(ticker, data, years):
+    # Get the total return values for the last n years
+    trailing_data = data[ticker].tail(years)
+    # Check if there are empty values within years
+    if trailing_data.isna().any():
+        return "N/A"
+    # Check if there are valid total return values for all years
+    if len(trailing_data) == years:
+        # Convert the percentage strings to numeric values
+        trailing_data = trailing_data.astype(str).str.replace('%', '').astype(float)
+        """ Calculate the annualized trailing total return using the formula from Investopedia[^1^][1]:
+            Annualized Return = [(1 + r1) * (1 + r2) * ... * (1 + rn)]^(1/n) - 1
+            Where r1, r2, ..., rn are the total return values for each year                    """
+        annualized_trailing_return = (trailing_data + 1).prod() ** (1 / years) - 1
+
+        # Format the result as a percentage with two decimal places
+        annualized_trailing_return = annualized_trailing_return * 100
+        annualized_trailing_return = annualized_trailing_return.round(2)
+        return annualized_trailing_return
+    else:
+        return "N/A"
+
+# Define a function to Loop through the list and print the trailing returns for each num_years
+def get_trailing_return_column(ticker, annual_returns_df):
+    trailing_return_column = {}
+    for num_years in years_list:
+        # Check if the ticker data is available in all_tickers_returns_df
+        if ticker in annual_returns_df.columns:
+            # using data from step 1, avoiding get_annual_returns_df(ticker) for less traffic from yahoo server
+            data = annual_returns_df[[ticker]]
+            trailing_return = get_trailing_return(ticker, data, num_years)
+            trailing_return_column[f"{num_years}-Year"] = trailing_return
+        else:
+            print(f"Data not available for {ticker}. Skipping.")
+            trailing_return_column[f"{num_years}-Year"] = "N/A"
+    return trailing_return_column
+
+# Create an empty DataFrame to store all tickers' trailing returns
+def get_trailing_return_all(tickers, annual_returns_df):
+    all_tickers_trailing_returns_df = pd.DataFrame(index=years_list)
+
+    # Loop through each ticker in the list
+    for ticker in tickers:
+        trailing_returns = get_trailing_return_column(ticker, annual_returns_df)
+        # Add the trailing returns to the DataFrame
+        all_tickers_trailing_returns_df[ticker] = pd.Series(trailing_returns).values
+    return all_tickers_trailing_returns_df
+
+#==============================================================================
+# Part 3: calculate the cumulative return from the data (all_tickers_returns_df) generated in part 1 & display
+#  Define a function to calculate the cumulative return for a given number of years from a ticker
+def get_cumulative_return(ticker, data, years):
+    # Calculate the cumulative return
+    cumulative_return = (1 + data[ticker]).rolling(window=years).apply(lambda x: x.prod(), raw=True) - 1
+    return cumulative_return
+
+# Define a function to Loop through the list and return the cumulative returns for each num_years
+def get_cumulative_return_column(ticker, annual_returns_df):
+    cumulative_returns = {}
+    for years in years_list:
+        # Calculate the cumulative return for the given number of years
+        cumulative_return = get_cumulative_return(ticker, annual_returns_df, years)
+        # Get the last value, which is the cumulative return up to the current year
+        cumulative_returns[years] = cumulative_return.iloc[-1]
+    return cumulative_returns
+
+def get_cumulative_return_all(tickers, annual_returns_df):
+    # Create an empty DataFrame with years_list as the index for cumulative  returns
+    all_tickers_cumulative_returns_df = pd.DataFrame(index=years_list)
+    # Loop through each ticker in the list
+    for ticker in tickers:
+        cumulative_returns = get_cumulative_return_column(ticker, annual_returns_df)
+        # Add the trailing returns to the DataFrame
+        all_tickers_cumulative_returns_df[ticker] = pd.Series(cumulative_returns).values
+    return all_tickers_cumulative_returns_df
+
+#==============================================================================
+# Part 4: calculate the  CAGR (Compound Annual Growth Rate) from the data
+# in all_tickers_cumulative_returns_df generated earlier & display
+# Define a function to calculate the CAGR from the cumulative value and the years
+def calculate_cagr(value, years):
+    # Otherwise, calculate the CAGR using the formula
+    cagr = (value + 1) ** (1 / np.array(years)) - 1
+    #print("debug-cagr\n", cagr, "end")
+    return cagr
+
+# Define a function to format the Float64Index values into percentage strings
+def format_to_percentage(value):
+    # If any element in the value array is not null, format it as a percentage string with two decimal places
+    if np.any(pd.notnull(value)):
+        return f"{value:.2f}%"
+    # Otherwise, return None
+    return None
+
+def get_cagr_return_all(all_tickers_cumulative_returns_df):
+    # Apply the calculate_cagr function to each column of the DataFrame
+    all_tickers_cagrs_df = all_tickers_cumulative_returns_df.apply(lambda x: calculate_cagr(x, x.index), axis=0)
+    return all_tickers_cagrs_df
+
+#==============================================================================
+# Part 5: utility functions
+# get the last trading day of S&P 500 in string format
+def get_last_trading_day():
+    # Get today's date, use .strftime("%Y-%m-%d") to convert to a string
+    today_date_str=datetime.now(pytz.timezone('America/New_York')).date().strftime("%Y-%m-%d")
+    stock = yf.Ticker("^GSPC") # S&P 500 (^GSPC) ticker
+    #  search and see yfinance_BUG_1 NOTE in this file
+    history_df=stock.history(period="max", end=today_date_str)["Close"]
+    last_trading_day_str = history_df.index.max().date().strftime("%Y-%m-%d")
+    return last_trading_day_str
+
+def str_to_integer(integer_str):
+    try:
+        integer_number = int(integer_str)
+        return integer_number
+    except ValueError:
+        return -1
+
+# validate the date string
+def is_valid_date(date_string):
+    try:
+        # Attempt to parse the date string
+        datetime.strptime(date_string, "%Y-%m-%d")
+        return True
+    except ValueError:
+        # Raised when the date string is not in the expected format
+        return False
+
+def date_label_conversion_strip_time(all_tickers_returns_df, calculation_end_date_str):
+    all_tickers_returns_df.index=all_tickers_returns_df.index.date
+    all_tickers_returns_df.index.name='date'
+    # print("debug get_annual_returns_tickers_df", all_tickers_returns_df)
+    # Convert calculation_end_date_str to a datetime object, replace the index's mon/day portion of date
+    end_date_datetime_obj = datetime.strptime(calculation_end_date_str, "%Y-%m-%d")
+    all_tickers_returns_df.index = all_tickers_returns_df.index.map(
+      lambda x: x.replace(month=end_date_datetime_obj.month,
+      day=end_date_datetime_obj.day))
+    return all_tickers_returns_df
+
+#==============================================================================
+# Part 6:
+# single ticker's Prices, Returns,Dividends, good for verifying whether "Adj Close" is correct.
+'''
+    Calculate and display: yearly dividendSum, 'Close' & 'Adj Close' prices,
+    Return(by 'Close' price), total return(by 'Adj Close' price),
+    CalReturn(total return by 'Close' price and "dividendSum).
+    Note: CalReturn from  is expected to be nearly same as  total return,
+           when the 'Adj Close' price is correct.
+'''
+def get_yearly_single_stock_data(ticker):
+    stock = yf.Ticker(ticker)
+    #-------- mainly for downloading 'Dividends'
+    history = stock.history(period="max")
+    dividend_history=history['Dividends']
+    dividend_history.index=dividend_history.index.date
+
+    #-------- mainly for downloading 'Close','Adj Close'
+    dld_history=yf.download(ticker, period="max")
+    dld_history=dld_history[['Close','Adj Close']]
+    dld_history.rename(columns={'Adj Close': 'AdjClose'}, inplace=True)
+    date_range = pd.date_range(start=dld_history.index.min(), end=dld_history.index.max(), freq='D')
+    complete_history = pd.DataFrame(index=date_range)
+
+    # Merge the complete DataFrame with the original stock_history
+    complete_history = complete_history.merge(dld_history, how='left', left_index=True, right_index=True)
+    complete_history[['Close','AdjClose']] = complete_history[['Close','AdjClose']].ffill().round(3)
+
+    # Merge dividend into complete_history
+    complete_history = complete_history.merge(dividend_history, how='left', left_index=True, right_index=True)
+    # replace all NaN values in the 'Dividends' column with 0.0
+    complete_history['Dividends'] = complete_history['Dividends'].fillna(0.0).round(3)
+
+    complete_history['Year']=complete_history.index.year
+    complete_history['Date']=complete_history.index
+    yearly_data = complete_history.groupby('Year').agg({'Date': 'last', 'Close': 'last', 'AdjClose': 'last','Dividends': 'sum'})
+    yearly_data.rename(columns={'Dividends': 'DivSum'}, inplace=True)
+
+    # calculating 'Return' and 'TotalReturn'
+    yearly_data['DivRatio']=yearly_data['DivSum'] / yearly_data['Close']
+    yearly_data['Return']=yearly_data['Close'].pct_change()
+    yearly_data['TotalReturn']=yearly_data['AdjClose'].pct_change()
+
+    '''
+    The CalReturn column is the yearly total return calculated from un-adjusted "Close" prices and yearly "dividend sum",
+    which is expected to be equal to the total return that is calculated from "AdjClose" prices
+    '''
+    yearly_data['CalReturn'] = (yearly_data['Close'] + yearly_data['DivSum']) / yearly_data['Close'].shift(1) - 1
+    # set the display format
+    yearly_data[['DivRatio','Return','TotalReturn','CalReturn']] = yearly_data[['DivRatio','Return','TotalReturn','CalReturn']].mul(100).round(2)
+    yearly_data[['DivRatio','Return', 'TotalReturn', 'CalReturn']] = yearly_data[['DivRatio','Return', 'TotalReturn', 'CalReturn']].applymap("{:.2f}%".format)
+    # 'Date' column is no longer required
+    yearly_data.drop('Date', axis=1, inplace=True)
+    return yearly_data
+
+#==============================================================================
+# Part 7: gradio handling - Input command handling and display in web page
+
+help_info_str="Input Formats:\n  \
+            1. ticker list....................Example:  spy vfv.to xiu.to xic.to xfn.to ry.to \n \
+            2. One of default ticker list, a number between 1 and 5....Example:   0, or 1, ...,5 \n \
+            3. CalculationEndDate as prefix.  Example:   2020-12-31 2 \n \
+            .........................................2020-12-31 spy vfv.to xiu.to xic.to xfn.to ry.to \n \
+            4. single ticker: Dividend/Close/AdjClose/Return/TotalReturn/CalReturn(by Close/Dividends).  @1 spy \n \
+            note: daily adjusted close data are from Yahoo Finance. "
+
+# Gradio Web interface
+def calculation_response(message, history):
+    # if there is no input, display help information
+    if message=="":
+        return help_info_str
+
+    tickers=message.split()
+
+    # ******************************************************************************
+    #  processing web input parameters
+    #  set calculation_end_date_str, and tickers
+
+    #---------------------------------------------------------
+    # single stock ticker - detailed information
+    if (tickers[0] == "@1"):
+        tickers.pop(0) # remove the first string which is "@1"
+        if len(tickers)==0:
+            ticker = 'spy' # default ticker = spy
+        else:
+            ticker=tickers[0]
+        output_string=f"\n {ticker}\n"
+        output_dataframe0=get_yearly_single_stock_data(ticker)
+        output_html=output_string + output_dataframe0.to_html()
+        return output_html
+
+    #----------------------------------------------------------
+    # Get today's date, use .strftime("%Y-%m-%d") to convert to a string
+    #calculation_end_date_str=datetime.now(pytz.timezone('America/New_York')).date().strftime("%Y-%m-%d")
+    calculation_end_date_str = get_last_trading_day()
+    # Check whether the first str is date for calculation end date
+    if is_valid_date(tickers[0]):
+        calculation_end_date_str = tickers[0] # reset calculation_end_date_str
+        tickers.pop(0) # remove the first string which is the date
+
+    #............ For display trailing and cumulative returns at month_boundary_date
+    # Assuming calculation_end_date_str contains the date string '2024-01-03'
+    calculation_end_date = datetime.strptime(calculation_end_date_str, '%Y-%m-%d')
+    # Calculate the first day of the current month
+    first_day_of_month = calculation_end_date.replace(day=1)
+    # Calculate the last day of the month
+    last_day_of_month = (calculation_end_date.replace(day=1) + timedelta(days=32)).replace(day=1) - timedelta(days=1)
+    # Calculate the last day of the previous month
+    last_day_of_previous_month = first_day_of_month - timedelta(days=1)
+    # Check if the original date is the last day of the month
+    if (calculation_end_date == last_day_of_month):
+        calculation_end_date_month_boundary_date_str=calculation_end_date_str
+    else:
+        calculation_end_date_month_boundary_date_str=last_day_of_previous_month.strftime('%Y-%m-%d')
+    # calculation_end_date_for_others are for trailing and cumulative returns
+    calculation_end_date_for_others_str=calculation_end_date_month_boundary_date_str
+
+    ''' TODO handling Feb 29 of leap year.
+    Check if involved dates (in calculation_end_date_str and calculation_end_date_for_others_str),
+    Feb 28 will be used to replace Feb 29 for calculation
+    '''
+    #................End
+
+    # Check whether numebr 0, 1, 2, .. is selected for using a default ticker list
+    integer_value=str_to_integer(tickers[0])
+    if (integer_value >= 0 and integer_value <len(tickers_lists)):
+        tickers=tickers_lists[integer_value]
+
+    # if no tickers were set, display help information
+    if len(tickers)==0:
+        return help_info_str
+
+    #*********************************************************************************
+    # Calculating Annual, Trailing, Cumulative, and CAGR & generating html for display
+    # annual_returns - at year end boundard, to be displayed
+    output_string = f"\nAnnual Total Return (%) as {calculation_end_date_str}\n"
+    output_dataframe = get_annual_returns_tickers_year_boundary_df(tickers, calculation_end_date_str)
+    output_dataframe = output_dataframe.round(4)*100
+    output_dataframe.index=output_dataframe.index.date
+    # Assuming your DataFrame is named output_dataframe
+    last_date = output_dataframe.index[-1]
+    output_dataframe = output_dataframe.rename(index={last_date: calculation_end_date_str})
+    # Convert the DataFrame to HTML, Combine the expected string outputs
+    output_html1 = output_string + output_dataframe.to_html()
+
+    # annual_returns  - at any given day, for calculating trailing and cumulative returns, not to be displayed
+    annual_returns_dataframe=get_annual_returns_tickers_df(tickers, calculation_end_date_for_others_str)
+
+    # Trailing Return
+    output_string2 = f"\nTrailing Total Return (%) as {calculation_end_date_for_others_str}\n"
+    output_dataframe2=get_trailing_return_all(tickers, annual_returns_dataframe)
+    # Insert an empty to align the ticker symbols with annual return display
+    output_dataframe2.insert(0, "--------", "      ")
+    output_dataframe2.index.name="years"
+    output_html2=output_string2 + output_dataframe2.to_html()
+
+    # Cumulative Return
+    output_string3 = f"\nCumulative Return (%) as {calculation_end_date_for_others_str}\n"
+    cumulative_return_all_dataframe=get_cumulative_return_all(tickers, annual_returns_dataframe)
+    output_dataframe3=cumulative_return_all_dataframe.round(4)*100
+    output_dataframe3.index.name="years"
+    output_html3=output_string3 + output_dataframe3.to_html()
+
+    # CAGR Return
+    output_string4 = f"\nCompound Annual Growth Rate (CAGR) (%) as {calculation_end_date_for_others_str}\n"
+    output_dataframe4=get_cagr_return_all (cumulative_return_all_dataframe)
+    output_dataframe4=output_dataframe4.round(4)*100
+    output_html4=output_string4 + output_dataframe4.to_html()
+
+    #output_html = output_html1 + output_html2 + output_html3 + output_html4
+    output_html = output_html1 + output_html2 + output_html3
+    return  output_html
+
+demo = gr.ChatInterface(calculation_response)
+demo.launch(debug=False, share=False)