import requests
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from matplotlib.pyplot import figure
from matplotlib.offsetbox import OffsetImage, AnnotationBbox
#from scipy import stats
import matplotlib.lines as mlines
import matplotlib.transforms as mtransforms
import numpy as np
#import plotly.express as px
#!pip install chart_studio
# import chart_studio.tools as tls
#from bs4 import BeautifulSoup
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.font_manager as font_manager
from datetime import datetime
import pytz
from datetime import date
datetime.now(pytz.timezone('US/Pacific')).strftime('%B %d, %Y')
# Configure Notebook
#%matplotlib inline
plt.style.use('fivethirtyeight')
sns.set_context("notebook")
import warnings
warnings.filterwarnings('ignore')
#from urllib.request import urlopen
import json
from datetime import date, timedelta
#import dataframe_image as dfi
#from os import listdir
#from os.path import isfile, join
import datetime
import seaborn as sns
import os
import calendar
#from IPython.display import display, HTML
import matplotlib.image as mpimg
#from skimage import io
#import difflib 


from datetime import datetime
import pytz
datetime.now(pytz.timezone('US/Pacific')).strftime('%B %d, %Y')
# Configure Notebook
#%matplotlib inline
plt.style.use('fivethirtyeight')
sns.set_context("notebook")
import warnings
warnings.filterwarnings('ignore')
# import yfpy
# from yfpy.query import YahooFantasySportsQuery
# import yahoo_oauth
import json
#import openpyxl
#from sklearn import preprocessing
from PIL import Image
import logging
import matplotlib.patches as patches
from matplotlib.patches import Rectangle
from matplotlib.font_manager import FontProperties
from matplotlib.offsetbox import OffsetImage, AnnotationBbox

import requests
#import pickle
import pandas as pd

# # Loop over the counter and format the API call
r = requests.get('https://statsapi.web.nhl.com/api/v1/schedule?startDate=2023-10-01&endDate=2024-06-01')
schedule = r.json()

def flatten(t):
    return [item for sublist in t for item in sublist]

game_id = flatten([[x['gamePk'] for x in schedule['dates'][y]['games']] for y in range(0,len(schedule['dates']))])
game_date = flatten([[x['gameDate'] for x in schedule['dates'][y]['games']] for y in range(0,len(schedule['dates']))])
game_home = flatten([[x['teams']['home']['team']['name'] for x in schedule['dates'][y]['games']] for y in range(0,len(schedule['dates']))])
game_away = flatten([[x['teams']['away']['team']['name'] for x in schedule['dates'][y]['games']] for y in range(0,len(schedule['dates']))])

schedule_df = pd.DataFrame(data={'game_id': game_id, 'game_date' : game_date, 'game_home' : game_home, 'game_away' : game_away})
schedule_df.game_date = pd.to_datetime(schedule_df['game_date']).dt.tz_convert(tz='US/Eastern').dt.date
schedule_df = schedule_df.replace('Montréal Canadiens','Montreal Canadiens')
schedule_df.head()

team_abv = pd.read_csv('team_abv.csv')
yahoo_weeks = pd.read_csv('yahoo_weeks.csv')
#yahoo_weeks['Number'] = yahoo_weeks['Number'].astype(int)
yahoo_weeks['Start'] = pd.to_datetime(yahoo_weeks['Start'])
yahoo_weeks['End'] = pd.to_datetime(yahoo_weeks['End'])
yahoo_weeks.head(5)

def highlight_cols(s):
    color = '#C2FEE9'
    return 'background-color: %s' % color
def highlight_cells(val):
    color = 'white' if val == ' ' else ''
    return 'background-color: {}'.format(color)

import matplotlib.pyplot as plt
import matplotlib.colors
cmap_total = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#56B4E9","#FFFFFF","#F0E442"])
cmap_off = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#FFFFFF","#F0E442"])
cmap_back = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#FFFFFF","#56B4E9"])
cmap_sum = matplotlib.colors.LinearSegmentedColormap.from_list("", ["#FFFFFF","#F0E442"])

schedule_df = schedule_df.merge(right=team_abv,left_on='game_away',right_on='team_name',how='inner',suffixes=['','_away']) 
schedule_df = schedule_df.merge(right=team_abv,left_on='game_home',right_on='team_name',how='inner',suffixes=['','_home']) 
schedule_df['away_sym'] = '@'
schedule_df['home_sym'] = 'vs'


if not os.path.isfile('standings/standings_'+str(date.today())+'.csv'):   
    standings_df_old = pd.read_html('https://www.hockey-reference.com/leagues/NHL_2023_standings.html')[0].append(pd.read_html('https://www.hockey-reference.com/leagues/NHL_2023_standings.html')[1])
    standings_df_old.to_csv('standings/standings_'+str(date.today())+'.csv')
standings_df_old = pd.read_csv('standings/standings_'+str(date.today())+'.csv',index_col=[0])

standings_df = standings_df_old[standings_df_old['Unnamed: 0'].str[-8:] != 'Division'].sort_values('Unnamed: 0').reset_index(drop=True).rename(columns={'Unnamed: 0':'Team'})#.drop(columns='Unnamed: 0')
#standings_df = standings_df.replace('St. Louis Blues','St Louis Blues')
standings_df['GF/GP'] = standings_df['GF'].astype(int)/standings_df['GP'].astype(int)
standings_df['GA/GP'] = standings_df['GA'].astype(int)/standings_df['GP'].astype(int)
standings_df['GF_Rank']  = standings_df['GF/GP'].rank(ascending=True,method='first')/10-1.65
standings_df['GA_Rank'] = standings_df['GA/GP'].rank(ascending=False,method='first')/10-1.65
standings_df.Team = standings_df.Team.str.strip('*') 
standings_df = standings_df.merge(right=team_abv,left_on='Team',right_on='team_name')

schedule_stack = pd.DataFrame()
schedule_stack['date'] = pd.to_datetime(list(schedule_df['game_date'])+list(schedule_df['game_date']))
schedule_stack['team'] = list(schedule_df['team_name'])+list(schedule_df['team_name_home'])
schedule_stack['team_abv'] = list(schedule_df['team_abv'])+list(schedule_df['team_abv_home'])
schedule_stack['symbol'] = list(schedule_df['away_sym'])+list(schedule_df['home_sym'])
schedule_stack['team_opponent'] =  list(schedule_df['team_name_home'])+list(schedule_df['team_name'])
schedule_stack['team_abv_home'] = list(schedule_df['team_abv_home'])+list(schedule_df['team_abv'])
schedule_stack = schedule_stack.merge(right=standings_df[['team_abv','GF_Rank']],left_on='team_abv',right_on='team_abv',how='inner',suffixes=("",'_y'))
schedule_stack = schedule_stack.merge(right=standings_df[['team_abv','GA_Rank']],left_on='team_abv_home',right_on='team_abv',how='inner',suffixes=("",'_y'))

schedule_stack = schedule_stack.merge(right=standings_df[['team_abv','GF_Rank']],left_on='team_abv',right_on='team_abv',how='inner',suffixes=("",'_y'))
schedule_stack = schedule_stack.merge(right=standings_df[['team_abv','GA_Rank']],left_on='team_abv_home',right_on='team_abv',how='inner',suffixes=("",'_y'))
 
 
list_o = schedule_stack.sort_values(['team','date'],ascending=[True,True]).reset_index(drop=True)
new_list = [x - y for x, y in zip(list_o['date'][1:], list_o['date'])]
b2b_list = [0] + [x.days for x in new_list]
b2b_list = [1 if x==1 else 0 for x in b2b_list]
test = list(schedule_stack.groupby(by='date').count()['team'])
offnight = [1 if x<15 else 0 for x in test]
offnight_df = pd.DataFrame({'date':schedule_stack.sort_values('date').date.unique(),'offnight':offnight}).sort_values('date').reset_index(drop=True)
schedule_stack = schedule_stack.merge(right=offnight_df,left_on='date',right_on='date',how='right')
schedule_stack = schedule_stack.sort_values(['team','date'],ascending=[True,True]).reset_index(drop=True)
schedule_stack['b2b'] = b2b_list

schedule_stack.date = pd.to_datetime(schedule_stack.date)

away_b2b = []
home_b2b = []
for i in range(0,len(schedule_stack)):
    away_b2b.append(schedule_stack[(schedule_stack.date[i]==schedule_stack.date)&(schedule_stack.team_opponent[i]==schedule_stack.team)].reset_index(drop=True)['b2b'][0])
    home_b2b.append(schedule_stack[(schedule_stack.date[i]==schedule_stack.date)&(schedule_stack.team[i]==schedule_stack.team)].reset_index(drop=True)['b2b'][0])

schedule_stack['away_b2b'] = away_b2b
schedule_stack['home_b2b'] = home_b2b

schedule_stack['away_b2b'] = schedule_stack['away_b2b'].replace(1,' &#128564;')
schedule_stack['away_b2b'] = schedule_stack['away_b2b'].replace(0,'')
schedule_stack.head()

FontProperties(fname='/System/Library/Fonts/Apple Color Emoji.ttc')

data_r = requests.get("https://pub-api-ro.fantasysports.yahoo.com/fantasy/v2/league/427.l.public;out=settings/players;position=ALL;start=0;count=3000;sort=rank_season;search=;out=percent_owned;out=auction_values,ranks;ranks=season;ranks_by_position=season;out=expert_ranks;expert_ranks.rank_type=projected_season_remaining/draft_analysis;cut_types=diamond;slices=last7days?format=json_f").json()

total_list = []

for x in data_r['fantasy_content']['league']['players']:
    single_list = []

    single_list.append(int(x['player']['player_id']))
    single_list.append(int(x['player']['player_ranks'][0]['player_rank']['rank_value']))
    single_list.append(x['player']['name']['full'])
    single_list.append(x['player']['name']['first'])
    single_list.append(x['player']['name']['last'])
    single_list.append(x['player']['draft_analysis']['average_pick'])
    single_list.append(x['player']['average_auction_cost'])
    single_list.append(x['player']['display_position'])
    single_list.append(x['player']['editorial_team_abbr'])
    if 'value' in x['player']['percent_owned']:
        single_list.append(x['player']['percent_owned']['value']/100)
    else:
        single_list.append(0)
    total_list.append(single_list)

df_2023 = pd.DataFrame(data=total_list,columns=['player_id','rank_value','full','first','last','average_pick', 'average_cost','display_position','editorial_team_abbr','percent_owned'])

week_dict = yahoo_weeks.set_index('Number')['Week'].sort_index().to_dict()

from shiny import ui, render, App
import matplotlib.image as mpimg
# app_ui = ui.page_fluid(

#     # ui.output_plot("plot"),
#     #ui.h2('MLB Batter Launch Angle vs Exit Velocity'),
#     ui.layout_sidebar(
#         ui.panel_sidebar(
#             ui.input_select("id", "Select Batter",batter_dict),

#             ui.input_select("plot_id", "Select Plot",{'scatter':'Scatter Plot','dist':'Distribution Plot'})))
#         ,

#     ui.panel_main(ui.output_plot("plot",height = "750px",width="1250px")),
#     #ui.download_button('test','Download'),
# )
app_ui = ui.page_fluid(ui.layout_sidebar(
    # Available themes:
    #  cerulean, cosmo, cyborg, darkly, flatly, journal, litera, lumen, lux,
    #  materia, minty, morph, pulse, quartz, sandstone, simplex, sketchy, slate,
    #  solar, spacelab, superhero, united, vapor, yeti, zephyr
        
      ui.panel_sidebar(
            ui.input_select("week_id", "Select Week (Set as Season for Custom Date Range)",week_dict,width=1),
            ui.input_select("sort_id", "Sort Column",['Score','Team','Total','Off-Night','B2B'],width=1),
            ui.input_switch("a_d_id", "Ascending?"),
            #ui.input_select("date_id", "Select Date",yahoo_weeks['Week'],width=1),
            ui.input_date_range("date_range_id", "Date range input",start = datetime.today().date(), end = datetime.today().date() + timedelta(days=6)),
            ui.output_table("result"),width=3),
         
        
        ui.panel_main(ui.tags.h3(""),
                      ui.div({"style": "font-size:2em;"},ui.output_text("txt_title")),
                      #ui.tags.h2("Fantasy Hockey Schedule Summary"),
                      ui.tags.h5("Created By: @TJStats,     Data: NHL"),
                      ui.div({"style": "font-size:1.2em;"},ui.output_text("txt")),
                      ui.output_table("schedule_result"),
                      ui.tags.h5('Legend'),
                      ui.output_table("schedule_result_legend"),
                      ui.tags.h6('An Off Night is defined as a day in which less than half the teams in the NHL are playing'),
                      ui.tags.h6('The scores are determined by using games played, off-nights, B2B, and strength of opponents') )

        ))
        #  ui.row(
        #         ui.column(
        #             3,
        #                 ui.input_date("x", "Date input"),),
        #         ui.column(
        #             1,
        #             ui.input_select("level_id", "Select Level",level_dict,width=1)),
        #         ui.column(
        #             3,
        #             ui.input_select("stat_id", "Select Stat",plot_dict_small,width=1)),
        #         ui.column(
        #             2,
        #             ui.input_numeric("n", "Rolling Window Size", value=50)),
        #         ),
        #             ui.output_table("result_batters")),

                # ui.nav(
                #     "Pitchers",

                #                 ui.row(
                # ui.column(
                #     3,
                #     ui.input_select("id_pitch", "Select Pitcher",pitcher_dict,width=1,selected=675911),
                #     ),
                # ui.column(
                #     1,
                #     ui.input_select("level_id_pitch", "Select Level",level_dict,width=1)),
                # ui.column(
                #     3,
                #     ui.input_select("stat_id_pitch", "Select Stat",plot_dict_small_pitch,width=1)),
                # ui.column(
                #     2,
                #         ui.input_numeric("n_pitch", "Rolling Window Size", value=50)),
                # ),
                #     ui.output_table("result_pitchers")),
#             )
#         )
# )




from urllib.request import Request, urlopen
# importing OpenCV(cv2) module




def server(input, output, session):

    @output
    @render.text
    def txt():
        
        week_set = int(input.week_id())
        if week_set != 0:
            if pd.to_datetime(yahoo_weeks[yahoo_weeks.Number == week_set]['Start'].values[0]).year != pd.to_datetime(yahoo_weeks[yahoo_weeks.Number == week_set]['End'].values[0]).year:

                return f'{pd.to_datetime(yahoo_weeks[yahoo_weeks.Number == week_set]["Start"].values[0]).strftime("%B %d, %Y")} to {pd.to_datetime(yahoo_weeks[yahoo_weeks.Number == week_set]["End"].values[0]).strftime("%B %d, %Y")}'
            else:
                if pd.to_datetime(yahoo_weeks[yahoo_weeks.Number == week_set]["Start"].values[0]).month != pd.to_datetime(yahoo_weeks[yahoo_weeks.Number == week_set]["End"].values[0]).month:
                    return f'{pd.to_datetime(yahoo_weeks[yahoo_weeks.Number == week_set]["Start"].values[0]).strftime("%B %d")} to {pd.to_datetime(yahoo_weeks[yahoo_weeks.Number == week_set]["End"].values[0]).strftime("%B %d, %Y")}'
                else:
                    return f'{pd.to_datetime(yahoo_weeks[yahoo_weeks.Number == week_set]["Start"].values[0]).strftime("%B %d")} to {pd.to_datetime(yahoo_weeks[yahoo_weeks.Number == week_set]["End"].values[0]).strftime("%d, %Y")}'
        else:
            if input.date_range_id()[0].year != input.date_range_id()[1].year:

                return f'{input.date_range_id()[0].strftime("%B %d, %Y")} to {input.date_range_id()[1].strftime("%B %d, %Y")}'
            else:
                if input.date_range_id()[0].month != input.date_range_id()[1].month:
                    return f'{input.date_range_id()[0].strftime("%B %d")} to {input.date_range_id()[1].strftime("%B %d, %Y")}'
                else:
                    return f'{input.date_range_id()[0].strftime("%B %d")} to {input.date_range_id()[1].strftime("%d, %Y")}'            


    @output
    @render.text
    def txt_title():
        week_set = int(input.week_id())
        if week_set != 0:
            return f'Fantasy Hockey Schedule Summary - Yahoo - Week {input.week_id()}'
        else:
            return f'Fantasy Hockey Schedule Summary'

    @output
    @render.table
    def result():
        #print(yahoo_weeks)
        return yahoo_weeks

    @output
    @render.table
    def schedule_result():
        

        week_set = int(input.week_id())
        print(week_set)

        if week_set == 0:
            start_point = input.date_range_id()[0]
            end_point = input.date_range_id()[1]
        else:   
            start_point = yahoo_weeks[yahoo_weeks.Number==week_set].reset_index(drop=True)['Start'][0]
            end_point = yahoo_weeks[yahoo_weeks.Number==week_set].reset_index(drop=True)['End'][0]


        sort_value='Score'
        ascend=False

        weekly_stack = schedule_stack[(schedule_stack['date'].dt.date>=start_point)&(schedule_stack['date'].dt.date<=end_point)]
        date_list = pd.date_range(start_point,end_point,freq='d')
        test_list = [[]] * len(date_list)



        for i in range(0,len(date_list)):
            test_list[i]  = team_abv.merge(right=weekly_stack[weekly_stack['date']==date_list[i]],left_on='team_abv',right_on='team_abv',how='left')
            test_list[i] = test_list[i].fillna("")
            test_list[i]['new_text'] = test_list[i]['symbol'] + ' '+ test_list[i]['team_abv_home'] + test_list[i]['away_b2b']


        test_df = pd.DataFrame()
        test_df['Team'] = list(team_abv['team_abv'])
        test_df['Total'] = test_df.merge(right=weekly_stack.groupby('team_abv')['team_abv'].apply(lambda x: x[x != ''].count()),left_on=['Team'],right_index=True,how='left').fillna(0)['team_abv']
        test_df['Off-Night'] = test_df.merge(right=weekly_stack.groupby('team_abv').sum()['offnight'],left_on=['Team'],right_index=True,how='left').fillna(0)['offnight']
        test_df['B2B']= test_df.merge(right=weekly_stack.groupby('team_abv').sum()['b2b'],left_on=['Team'],right_index=True,how='left').fillna(0)['b2b']



        gf_rank = np.array(test_df.merge(right=weekly_stack.groupby('team_abv').mean()['GF_Rank'],left_on=['Team'],right_index=True,how='left').fillna(0)['GF_Rank'])
        ga_rank = np.array(test_df.merge(right=weekly_stack.groupby('team_abv').mean()['GA_Rank'],left_on=['Team'],right_index=True,how='left').fillna(0)['GA_Rank'])


        #games_vs_tired = np.array([float(i)*0.4 for i in list(weekly_stack.groupby('team_abv')['away_b2b'].apply(lambda x: x[x != ''].count()))])

        games_vs_tired = 0.4*np.array(test_df.merge(right=weekly_stack.groupby('team_abv')['away_b2b'].apply(lambda x: x[x != ''].count()),left_on=['Team'],right_index=True,how='left').fillna(0)['away_b2b'])


        team_score = test_df['Total']+test_df['Off-Night']*0.5+test_df['B2B']*-0.2+games_vs_tired*0.3+gf_rank*0.1+ga_rank*0.1

        test_df['Score'] = team_score


        cols = test_df.columns.tolist();
        L = len(cols) 
        test_df = test_df[cols[4:]+cols[0:4]]
        #return test_df#[cols[4:]+cols[0:4]]

        test_df = test_df.sort_values(by=[sort_value,'Score'],ascending = ascend)

        for i in range(0,len(date_list)):
            test_df[calendar.day_name[date_list[i].weekday()]+'<br>'+str(date_list[i].month)+'-'+'{:02d}'.format(date_list[i].day)] = test_list[i]['new_text']

        row = ['']*L
        for x in  test_df[test_df.columns[L:]]:
            row.append(int(sum(test_df[x]!=" ")/2))

        test_df = test_df.sort_values(by=input.sort_id(),ascending=input.a_d_id())

        test_df.loc[32] = row
        #test_df_html = HTML( test_df.to_html().replace("\\n","<br>") ) 
        offnight_list = [True if x <8 else False for x in test_df.iloc[-1][L:]]

        test_df.style.applymap(highlight_cols,subset = ((list(test_df.index[:-1]),test_df.columns[L:][offnight_list])))
        test_df_style = test_df.style.set_properties(**{'border': '3 px'},overwrite=False).set_table_styles([{
            'selector': 'caption',
            'props': [
                ('color', ''),
                ('fontname', 'Century Gothic'),
                ('font-size', '20px'),
                ('font-style', 'italic'),
                ('font-weight', ''),
                ('text-align', 'centre'),
                ]

                },{'selector' :'th', 'props':[('text-align', 'center'),('Height','px'),('color','black'),('border', '1px black solid !important')]},{'selector' :'td', 'props':[('text-align', 'center'),('font-size', '18px'),('color','black')]}],overwrite=False).set_properties(
                    **{'background-color':'White','index':'White','min-width':'75px'},overwrite=False).set_properties(
                    **{'background-color':'White','index':'White','min-width':'100px'},overwrite=False,subset = ((list(test_df.index[:]),test_df.columns[5:]))).set_table_styles(
            [{'selector': 'th:first-child', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
            [{'selector': 'tr:first-child', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
            [{'selector': 'tr', 'props': [('line-height', '20px')]}],overwrite=False).set_properties(
            **{'Height': '8px'},**{'text-align': 'center'},overwrite=False).hide_index()

        test_df_style = test_df_style.applymap(highlight_cols,subset = ((list(test_df.index[:-1]),test_df.columns[L:][offnight_list])))

        test_df_style = test_df_style.applymap(highlight_cells)
        test_df_style = test_df_style.background_gradient(cmap=cmap_total,subset = ((list(test_df.index[:-1]),test_df.columns[0])))
        test_df_style = test_df_style.background_gradient(cmap=cmap_total,vmin=0,vmax=np.max(test_df.Total[:len(test_df)-1]),subset = ((list(test_df.index[:-1]),test_df.columns[2])))
        test_df_style = test_df_style.background_gradient(cmap=cmap_off,subset = ((list(test_df.index[:-1]),test_df.columns[3])))
        test_df_style = test_df_style.background_gradient(cmap=cmap_back,subset = ((list(test_df.index[:-1]),test_df.columns[4])))
        test_df_style = test_df_style.background_gradient(cmap=cmap_sum,subset = ((list(test_df.index[-1:]),test_df.columns[L:])),axis=1)
        test_df_style = test_df_style.set_properties(
                    **{'border': '1px black solid !important'},subset = ((list(test_df.index[:-1]),test_df.columns[:]))).set_properties(
                    **{'min-width':'85px'},subset = ((list(test_df.index[:-1]),test_df.columns[L:])),overwrite=False).set_properties(**{
                                'color': 'black'},overwrite=False).set_properties(
                    **{'border': '1px black solid !important'},subset = ((list(test_df.index[:]),test_df.columns[L:])))

        test_df_style = test_df_style.format(
            '{:.0f}',subset=(test_df.index[:-1],test_df.columns[2:L]))

        test_df_style = test_df_style.format(
            '{:.1f}',subset=(test_df.index[:-1],test_df.columns[0]))


        print('made it to teh end')
        return test_df_style


        #return exit_velo_df_codes_summ_time_style_set

    # @output
    # @render.plot(alt="A histogram")
    # def plot_pitch():
    #     p
    @output
    @render.table
    def schedule_result_legend():

        off_b2b_df = pd.DataFrame(data={'off':'Off-Night','b2b':'Tired Opp. &#128564;'},index=[0])
        #off_b2b_df.style.applymap(highlight_cols,subset = ((list(off_b2b_df.index[:-1]),off_b2b_df.columns[0])))
        off_b2b_df_style = off_b2b_df.style.set_properties(**{'border': '3 px'},overwrite=False).set_table_styles([{
            'selector': 'caption',
            'props': [
                ('color', ''),
                ('fontname', 'Century Gothic'),
                ('font-size', '20px'),
                ('font-style', 'italic'),
                ('font-weight', ''),
                ('text-align', 'centre'),
                ]

                },{'selector' :'th', 'props':[('text-align', 'center'),('Height','px'),('color','black'),(
                    'border', '1px black solid !important')]},{'selector' :'td', 'props':[('text-align', 'center'),('font-size', '18px'),('color','black')]}],overwrite=False).set_properties(
                    **{'background-color':'White','index':'White','min-width':'150px'},overwrite=False).set_table_styles(
            [{'selector': 'th:first-child', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
            [{'selector': 'tr:first-child', 'props': [('background-color', 'white')]}],overwrite=False).set_table_styles(
            [{'selector': 'tr', 'props': [('line-height', '20px')]}],overwrite=False).set_properties(
            **{'Height': '8px'},**{'text-align': 'center'},overwrite=False).set_properties(
                **{'background-color':'#C2FEE9'},subset=off_b2b_df.columns[0]).set_properties(
                **{'color':'black'},subset=off_b2b_df.columns[:]).hide_index().set_table_styles([
            {'selector': 'thead', 'props': [('display', 'none')]}
            ]).set_properties(**{'border': '3 px','color':'black'},overwrite=False).set_properties(
                    **{'border': '1px black solid !important'},subset = ((list(off_b2b_df.index[:]),off_b2b_df.columns[:]))).set_properties(
                    **{'min-width':'130'},subset = ((list(off_b2b_df.index[:]),off_b2b_df.columns[:])),overwrite=False).set_properties(**{
                                'color': 'black'},overwrite=False).set_properties(
                    **{'border': '1px black solid !important'},subset = ((list(off_b2b_df.index[:]),off_b2b_df.columns[:])))
        
        return off_b2b_df_style






app = App(app_ui, server)