Add application file

App.py

@@ -0,0 +1,93 @@
+ # ----------------------------------LIBS -------------------------------------------------------------   
+import streamlit as st
+st.set_page_config(  # Alternate names: setup_page, page, layout
+	layout="wide",  # Can be "centered" or "wide". In the future also "dashboard", etc.
+	initial_sidebar_state="auto",  # Can be "auto", "expanded", "collapsed"
+	page_title=None,  # String or None. Strings get appended with "• Streamlit". 
+	page_icon=None,  # String, anything supported by st.image, or None.
+)
+
+import matplotlib
+matplotlib.use('Agg')
+
+from streamlit_option_menu import option_menu
+
+import warnings
+warnings.filterwarnings('ignore')
+ 
+import datetime as dt 
+dia = dt.datetime.today().strftime(format='20%y-%m-%d')
+
+import style as style
+import home as home
+import login as login
+import pag1 as pag1
+import pag2 as pag2
+import pag3 as pag3
+import pag4 as pag4
+import pag5 as pag5
+
+
+ # ----------------------------------DEFS -------------------------------------------------------------   
+
+#carrega os arquivos css
+def local_css(file_name):
+    with open(file_name) as f:
+        st.markdown(f'<style>{f.read()}</style>', unsafe_allow_html=True)
+
+def main():
+
+    #css comum para todas páginas (menu)
+    #local_css("style_0.css")  
+
+    #esconder botão de menu e marca dágua no rodapé
+    #style.hidden_menu_and_footer()
+
+    #cabeçalho detalhe superior da página 
+    #style.headerstyle()
+
+ # ----------------------------------MENU -------------------------------------------------------------   
+
+    with st.sidebar:
+        style.sidebarwidth()    
+        n_sprites = option_menu('Menu',["Home","Login","Análise técnica", "Comparar ações", "Análise fundamentalista", "Rastrear ações", "Previsão de lucro"],
+                            icons=['house','person','bar-chart', 'book', 'bullseye', 'binoculars','cash-coin'],
+                            default_index=0, menu_icon="app-indicator",   #orientation='horizontal',
+                            styles={
+            "container": {"padding": "2!important", "background-color": "#ffffff" }, # ,"background-size": "cover","margin": "0px"},
+            "nav-link": {"font-size": "12px", "text-align": "left", "--hover-color": "#4a7198","font-weight": "bold"}, #,"position": "relative","display": "inline"},
+            "nav-link-selected": {"background-color": "#4a7198"},
+             }) 
+
+ # ----------------------------------PAGES -------------------------------------------------------------     
+    if n_sprites == "Home":
+        #local_css("style_1.css")      
+        home.initial_page()
+    
+    if n_sprites == "Login":
+        #local_css("style_login.css")      
+        login.login_section()
+
+    if n_sprites == "Análise técnica":
+        #local_css("style_1.css")      
+        pag1.analise_tecnica_fundamentalista()
+
+    if n_sprites == "Comparar ações":
+        #local_css("style_2.css")   
+        pag2.comparacao_ativos()
+
+    if n_sprites == "Análise fundamentalista":
+        #local_css("style_3.css")   
+        pag3.descobrir_ativos()
+
+    if n_sprites == "Rastrear ações":
+        #local_css("style_4.css")   
+        pag4.rastreador()     
+
+    if n_sprites == "Previsão de lucro":
+        #local_css("style_5.css")  
+        pag5.analise_carteira()
+        
+if __name__ == '__main__':
+    main()
+

Procfile

@@ -0,0 +1 @@
+web: sh setup.sh && streamlit run App.py 

home.py

@@ -0,0 +1,20 @@
+import matplotlib
+matplotlib.use('Agg')
+
+import streamlit as st
+
+import html_home as html_home
+from PIL import Image
+
+def initial_page():
+
+        #código para ativar bootstrap css
+    st.markdown(
+"""
+<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
+""",unsafe_allow_html=True
+    )  
+
+    image = Image.open('images/home_image_2.jpeg')
+    st.image(image, use_column_width=True)  

html01.py

@@ -0,0 +1,62 @@
+import streamlit as st
+
+#card 
+def card_info(title, subtitle1, subtitle2, text, link):
+
+    st.markdown(
+        f"""
+    <div class="card-main" style="width: 100%;" "border-radius: 30px;">
+    <div class="card-body">
+        <h5 class="card-title" style="text-align: center;">{title}</h5>
+        <h6 class="card-subtitle mb-2 text-muted" style="text-align: center;">{subtitle1}</h6>
+        <h6 class="card-subtitle mb-2 text-muted" style="text-align: center;">{subtitle2}</h6>
+        <p class="card-text" style="text-align: left;">{text}</p>
+        <a href="#" class="card-link" style="text-align: center;">{link}</a>
+    </div>
+    </div>
+        """, unsafe_allow_html=True
+        )      
+
+
+
+
+
+
+
+
+
+
+
+
+# KPI com cards bootstrap
+# st.markdown(
+#         f"""
+#         <div class="card-deck" style= "-webkit-box-orient: horizontal;  width: 830px;" >
+
+#         <div class="card">
+#             <div class="card-body text-center">
+#             <p class="card-text" style="font-size: 20px; color: rgb(167, 174, 177); font-weight: bold;">P/L</p>
+#             <p class="card-text" style=" font-size: 40px">{fundamentus['P/L'][0]}</p>
+#             </div>
+#         </div>
+#         <div class="card">
+#             <div class="card-body text-center">
+#             <p class="card-text" style="font-size: 20px; color: rgb(167, 174, 177); font-weight: bold;">P/VP</p>
+#             <p class="card-text" style=" font-size: 40px;">{fundamentus['P/VP'][0]}</p>
+#             </div>
+#         </div>
+#         <div class="card">
+#             <div class="card-body text-center">
+#             <p class="card-text" style="font-size: 20px;color: rgb(167, 174, 177); font-weight: bold; ">Recomendação</p>
+#             <p class="card-text" style=" font-size: 40px; ">{info['recommendationKey']}</p>
+#             </div>
+#         </div>
+#         <div class="card">
+#             <div class="card-body text-center">
+#             <p class="card-text" style="font-size: 20px;color: rgb(167, 174, 177); font-weight: bold;">Próximo dividendo</p>
+#             <p class="card-text" style=" font-size: 20px;">{pfizer.calendar.transpose()['Earnings Date'].dt.strftime('%d/%m/%Y')[0]}</p>
+#             </div>
+#         </div>
+#         </div>
+#         """,unsafe_allow_html=True
+# )

html_home.py

@@ -0,0 +1,11 @@
+import streamlit as st
+
+#card 
+def home():
+
+    st.markdown(
+        f"""
+
+
+
+        """, unsafe_allow_html=True)

login.py

@@ -0,0 +1,81 @@
+import matplotlib
+matplotlib.use('Agg')
+
+import streamlit as st
+
+import pandas as pd
+
+def login_section():
+
+        #código para ativar bootstrap css
+    st.markdown(
+"""
+<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
+""",unsafe_allow_html=True
+    )  
+
+    users = pd.read_csv('users.csv', sep=';',dtype=str)
+
+    col1, col2, col3,col4,col5 = st.columns([1,1,1,1,1])   
+    with col2:  
+
+        st.header('Login')
+
+        username = st.text_input("User Name")
+        password = st.text_input("Password",type='password')   
+
+        if 'username' not in st.session_state:
+            st.session_state['username'] = [username]
+
+        if 'loged' not in st.session_state:
+            st.session_state['loged'] = ''  
+
+        if st.button('Login'):
+            if len(users[users['user'].str.contains(username, na=False)]) > 0:
+                if len(users[users['pass'].str.contains(password, na=False)]) > 0:
+                    st.session_state['loged'] = 'Logado'
+
+            else:
+                st.text('Senha incorreta')
+
+            if password == users['pass'][0]:
+                st.write('acesso manager')
+                st.dataframe(users)
+
+
+        #esse código iniciará em outras páginas as funções para quem estiver logado
+        if st.session_state['loged']:
+            st.write(st.session_state['loged'])
+
+    with col4: 
+
+        st.header('Cadastro')
+
+        cad_nome = st.text_input("Nome")
+        cad_email = st.text_input("Email")
+        cad_username = st.text_input("Cadastre um nome de usuário")
+        cad_password = st.text_input("Cadastre uma senha",type='password')
+        cad_password_2 = st.text_input("Repita a senha",type='password')  
+        cad_premium = 'não'
+
+        df_cad = pd.DataFrame( [[cad_nome,cad_username,cad_password,cad_email, cad_premium]] ,columns=['name','user','pass','email','premium'] )    
+
+        if st.button('Cadastrar'):
+            if len(users[users['user'].str.contains(cad_username, na=False)]) == 0:
+                dfs = [users,df_cad]
+                users = pd.concat( dfs,axis=0,ignore_index=True)
+                users.to_csv('users.csv', index=False, sep=';')
+                st.text('Cadastro efetuado com sucesso, realize o Login')  
+            else:
+                st.text('Usuário já existente')         
+
+
+
+
+
+
+
+
+
+

pag1.py

@@ -0,0 +1,466 @@
+import matplotlib
+matplotlib.use('Agg')
+
+#from turtle import width
+import streamlit as st
+from yahooquery import Ticker
+import pandas as pd
+import yfinance as yf
+# from fbprophet import Prophet
+import numpy as np
+import plotly.graph_objects as go
+
+import scrap as scraping
+
+import style as style
+
+import html01 as html01
+
+
+def analise_tecnica_fundamentalista():
+
+    #código para ativar bootstrap css
+    st.markdown(
+"""
+<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
+""",unsafe_allow_html=True
+    )  
+    
+    col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+    with col2:   
+        st.title('Análise Técnica')
+        st.subheader('Escolha o ativo que deseja analisar e pressione enter')  
+        #nome_do_ativo = st.text_input('Nome do ativo ex: PETR4, VALE3, WEGE3...')
+        codigo_nome = pd.read_excel('data/classification_b3.xlsx')
+        nome_do_ativo = st.selectbox('Esoolha a ação que deseja analisar', (codigo_nome['TICKER']) )
+
+    style.space(1)
+
+    if nome_do_ativo != "":
+        nome_do_ativo = str(nome_do_ativo + '.SA').upper()
+        df = Ticker(nome_do_ativo,country='Brazil')
+        time = df.history( period='max')
+
+    # ------------------------------ RESUMO ---------------------------- 
+
+        resumo = pd.DataFrame(df.summary_detail)
+        resumo = resumo.transpose()
+        if len(nome_do_ativo) == 8:
+            fundamentus = scraping.get_specific_data(nome_do_ativo[:5])
+            fundamentus = pd.DataFrame([fundamentus])
+    
+            try:
+
+                pfizer = yf.Ticker(nome_do_ativo)
+                info = pfizer.info 
+                if info['recommendationKey'] == 'buy':
+                    recomendation = 'alta'
+                else:
+                    recomendation = 'baixa'
+
+                #KPIS
+                metric1, metric2, metric3, metric4 = st.columns([1,1,1,1])
+                
+                with metric1:
+                    st.metric(label="P/L",value=f"{fundamentus['P/L'][0]}")
+                with metric2:
+                    st.metric(label="P/VP",value=f"{fundamentus['P/VP'][0]}")
+                with metric3:
+                    st.metric(label="Tendência", value=f"{recomendation}")
+                with metric4:
+                    st.metric(label="Próximo dividendo", value=f"{pfizer.calendar.transpose()['Earnings Date'].dt.strftime('%d/%m/%Y')[0]}")
+
+                style.space(2)
+
+                #card info
+                html01.card_info(info['longName'], info['sector'], info['industry'], info['longBusinessSummary'], info['website'])
+
+                style.space(2)    
+
+            except:
+                exit
+            
+        else:
+            st.write('---------------------------------------------------------------------')
+            st.dataframe(resumo) 
+            pfizer = yf.Ticker(nome_do_ativo)
+            info = pfizer.info 
+            st.title('Company Profile')
+            st.subheader(info['longName']) 
+            try:
+                st.markdown('** Sector **: ' + info['sector'])
+                st.markdown('** Industry **: ' + info['industry'])
+                st.markdown('** Website **: ' + info['website'])
+            except:
+                exit
+        
+    # ------------------------------ GRÁFICOS DE RENDIMENTO ---------------------------- 
+
+        if len(nome_do_ativo) == 8:
+            
+            import datetime
+            fundamentalist = df.income_statement()
+            fundamentalist['data'] = fundamentalist['asOfDate'].dt.strftime('%d/%m/%Y')
+            fundamentalist = fundamentalist.drop_duplicates('asOfDate')
+            fundamentalist = fundamentalist.loc[fundamentalist['periodType'] == '12M']
+
+            #volatilidade
+            TRADING_DAYS = 360
+            returns = np.log(time['close']/time['close'].shift(1))
+            returns.fillna(0, inplace=True)
+            volatility = returns.rolling(window=TRADING_DAYS).std()*np.sqrt(TRADING_DAYS)
+            vol = pd.DataFrame(volatility.iloc[-360:]).reset_index()
+
+            #sharpe ratio
+            sharpe_ratio = returns.mean()/volatility
+            sharpe = pd.DataFrame(sharpe_ratio.iloc[-360:]).reset_index()
+
+            div = time.reset_index()
+            div['year'] = pd.to_datetime(div['date']).dt.strftime('%Y')
+            div_group = div.groupby('year').agg({'close':'mean','dividends':'sum'})
+            div_group['dividendo(%)'] = round((div_group['dividends'] * 100 ) / div_group['close'],4)
+
+            from plotly.subplots import make_subplots
+            fig = make_subplots(
+                rows=3, cols=2,
+                specs=[[{"type": "bar"}, {"type": "bar"}],
+                    [{"type": "bar"}, {"type": "bar"}],
+                    [{"type": "scatter"}, {"type": "scatter"}]],
+                subplot_titles=("Receita Total","Lucro",'Dividendos (%)','Dividendos unitário R$','Volatilidade', 'Sharpe ratio (Retorno/ Risco)')
+            )
+
+            fig.add_trace(go.Bar(x =pfizer.financials.transpose().index,  y=pfizer.financials.transpose()['Total Revenue']), row=1, col=1)
+
+            fig.add_trace(go.Bar(x =pfizer.financials.transpose().index,  y=pfizer.financials.transpose()['Net Income From Continuing Ops']), row=1, col=2)
+
+            fig.add_trace(go.Bar(x =div_group.reset_index().tail(5)['year'],  y=div_group.reset_index().tail(5)['dividendo(%)']),row=2, col=1)
+
+            fig.add_trace(go.Bar(x =div_group.reset_index().tail(5)['year'],  y=div_group.reset_index().tail(5)['dividends']),row=2, col=2)
+
+            fig.add_trace(go.Scatter(x =vol['date'],  y=vol['close']),row=3, col=1)
+
+            fig.add_trace(go.Scatter(x =sharpe['date'],  y=sharpe['close']),row=3, col=2)
+
+            fig.update_layout( height=800, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+            fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+            col1, col2, col3 = st.columns([1,8,1])
+            #with col2: 
+            st.plotly_chart(fig,use_container_width=True)     
+                
+
+        else:
+            #volatilidade
+            TRADING_DAYS = 160
+            returns = np.log(time['close']/time['close'].shift(1))
+            returns.fillna(0, inplace=True)
+            volatility = returns.rolling(window=TRADING_DAYS).std()*np.sqrt(TRADING_DAYS)
+            vol = pd.DataFrame(volatility.iloc[-160:]).reset_index()
+
+            #sharpe ratio
+            sharpe_ratio = returns.mean()/volatility
+            sharpe = pd.DataFrame(sharpe_ratio.iloc[-160:]).reset_index()
+
+            from plotly.subplots import make_subplots
+            fig = make_subplots(
+                rows=1, cols=2,
+                specs=[[{"type": "scatter"}, {"type": "scatter"}]],
+                subplot_titles=('Volatilidade', 'Sharpe ratio (Retorno/ Risco)')
+            )
+
+            fig.add_trace(go.Scatter(x =vol['date'],  y=vol['close']),row=1, col=1)
+
+            fig.add_trace(go.Scatter(x =sharpe['date'],  y=sharpe['close']),row=1, col=2)
+
+            fig.update_layout( height=800, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+            fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+
+            col1, col2, col3 = st.columns([1,8,1])
+            #with col2: 
+            st.plotly_chart(fig,use_container_width=True)      
+
+    # ------------------------------ GRÁFICOS DE Candlestick---------------------------- 
+        with st.expander("Entenda o gráfico de Candlestick, clique para saber mais"):
+            st.write("""Gráfico de Candlestick , O formato contém os valores dos preços que a ação atingiu durante o período de tempo que está sendo analisado. São os preços de:""")
+            st.write('Abertura: preço pelo qual foi fechado o primeiro negócio do período')
+            st.write('Fechamento: preço pelo qual foi fechado o último negócio do período')
+            st.write('Máximo: maior preço negociado no período')
+            st.write('Mínimo: menor preço negociado no período')   
+        
+        fig = make_subplots(rows=2, cols=1, shared_xaxes=True, 
+            vertical_spacing=0.03, subplot_titles=('Candlestick', 'Volume'), 
+            row_width=[0.2, 0.7])
+
+        # Plot OHLC on 1st row
+        fig.add_trace(go.Candlestick(x=time.reset_index()['date'][-90:],
+                        open=time['open'][-90:], high=time['high'][-90:],
+                        low=time['low'][-90:], close=time['close'][-90:], name="OHLC"), 
+                        row=1, col=1)            
+
+        # Bar trace for volumes on 2nd row without legend
+        fig.add_trace(go.Bar(x=time.reset_index()['date'][-90:], y=time['volume'][-90:], showlegend=False), row=2, col=1)
+
+        # Do not show OHLC's rangeslider plot 
+        fig.update(layout_xaxis_rangeslider_visible=False)
+
+        fig.update_layout( height=600, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') #width=800 ,
+        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+
+
+        st.plotly_chart(fig,use_container_width=True)    
+        
+    # ------------------------------ GRÁFICOS DE Retorno acumulado---------------------------- 
+        with st.expander("Entenda o gráfico de Retorno acumulado, clique para saber mais"):
+            st.write("""Gráfico de Retorno acumulado, Acúmulo de retorno calculado desde a data de início escolhida até o dia de hoje.""")
+
+        layout = go.Layout(title="Retorno acumulado",xaxis=dict(title="Data"), yaxis=dict(title="Retorno"))
+        fig = go.Figure(layout = layout)
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-365:], y=time.reset_index()['close'][-365:].pct_change().cumsum(), mode='lines', line_width=3,line_color='rgb(0,0,0)'))
+
+        fig.update_layout( height=600, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+        st.plotly_chart(fig,use_container_width=True)   
+
+    # ------------------------------ GRÁFICOS DE Médias móveis---------------------------- 
+        with st.expander("Entenda o gráfico de Médias móveis, clique para saber mais"):
+            st.write("""Gráfico de Médias móveis, Cada ponto no gráfico representa a média dos últimos x dias, exemplo MM20 = média móvel dos última 20 dias.""")
+            st.write("""Com ela, é possível identificar o equilíbrio dos preços no mercado, observando tendências de alta, neutra ou baixa. A representação gráfica das Médias Móveis é normalmente feita por uma linha, que se movimenta conforme os dados novos recebidos para o cálculo.""")
+
+        rolling_200  = time['close'].rolling(window=200)
+        rolling_mean_200 = rolling_200.mean()
+
+        rolling_50  = time['close'].rolling(window=72)
+        rolling_mean_50 = rolling_50.mean()
+
+        rolling_20  = time['close'].rolling(window=20)
+        rolling_mean_20 = rolling_20.mean()
+
+        rolling_10  = time['close'].rolling(window=9)
+        rolling_mean_10 = rolling_10.mean()
+
+        layout = go.Layout(title="Médias móveis - ative ou desative clicando na legenda da média",xaxis=dict(title="Data"), yaxis=dict(title="Preço R$"))
+        fig = go.Figure(layout = layout)
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-120:], y=time["close"][-120:], mode='lines', line_width=3,name='Real',line_color='rgb(0,0,0)'))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-120:], y=rolling_mean_200[-120:],mode='lines',name='MM(200)',opacity = 0.6))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-120:], y=rolling_mean_50[-120:],mode='lines',name='MM(72)',opacity = 0.6))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-120:], y=rolling_mean_20[-120:],mode='lines',name='MM(20)',opacity = 0.6))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-120:], y=rolling_mean_10[-120:],mode='lines',name='MM(9)',opacity = 0.6,line_color='rgb(100,149,237)'))
+
+        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+        fig.update_layout(autosize=True, height=600, width=800 ,showlegend=True, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+        
+
+        st.plotly_chart(fig,use_container_width=True)     
+
+    # ------------------------------ GRÁFICOS DE Retração de Fibonacci---------------------------- 
+        with st.expander("Entenda o gráfico de Retração de Fibonacci, clique para saber mais"):
+            st.write("""Gráfico de Retração de Fibonacci, A retração de Fibonacci é composta por linhas horizontais que cortam a série de preços. A distância entre essas linhas varia obedecendo a chamada série numérica de Fibonacci. Na análise técnica esses valores são expressos em porcentagem e são: 100%, 61,8%, 38,2%, 23,6%, 0%.""")
+            st.write("""Muito utilizado para tentar identificar uma tendência de alta ou de baixa. Uma das técnicas é analisar se a ação caiu até a linha de 38,2% (verde) para voltar a subir (retração com tendência de alta) ou se caiu passando os 38,2% pode representar uma tendência de baixa ou alta com pouca força.""")
+            st.write('Tente sempre escolher a quantidade de dias analisados para começar a análise após o maior fundo de baixa histórico')
+        time_fibo = time.copy()
+
+        
+        periodo_fibonacci = int(st.number_input(label='periodo fibonacci - traçada do menor valor encontrado no período de tempo setado abaixo até o maior valor encontrado para frente',value= 45 ))
+        
+        Price_Min =time_fibo[-periodo_fibonacci:]['low'].min()
+        Price_Max =time_fibo[-periodo_fibonacci:]['high'].max()
+
+        Diff = Price_Max-Price_Min
+        level1 = Price_Max - 0.236 * Diff
+        level2 = Price_Max - 0.382 * Diff
+        level3 = Price_Max - 0.618 * Diff
+    
+        # st.write ('0% >>' f'{round(Price_Max,2)}')
+        # st.write ('23,6% >>' f'{round(level1,2)}')
+        # st.write ('38,2% >>' f'{round(level2,2)}')
+        # st.write ('61,8% >>' f'{round(level3,2)}')
+        # st.write ('100% >>' f'{round(Price_Min,2)}')
+
+        time_fibo['Price_Min'] = Price_Min
+        time_fibo['level1'] = level1
+        time_fibo['level2'] = level2
+        time_fibo['level3'] = level3
+        time_fibo['Price_Max'] = Price_Max
+
+        layout = go.Layout(title=f'Retração de Fibonacci',xaxis=dict(title="Data"), yaxis=dict(title="Preço"))
+        fig = go.Figure(layout = layout)
+        fig.add_trace(go.Scatter(x=time_fibo[-periodo_fibonacci:].reset_index()['date'], y=time_fibo[-periodo_fibonacci:].close, mode='lines', line_width=3,name='Preço real',line_color='rgb(0,0,0)'))
+        fig.add_trace(go.Scatter(x=time_fibo[-periodo_fibonacci:].reset_index()['date'], y=time_fibo[-periodo_fibonacci:].Price_Min, mode='lines', line_width=0.5,name='100%',line_color='rgb(255,0,0)',))
+        fig.add_trace(go.Scatter(x=time_fibo[-periodo_fibonacci:].reset_index()['date'], y=time_fibo[-periodo_fibonacci:].level3, mode='lines', line_width=0.5,name='61,8%',line_color='rgb(255,255,0)',fill= 'tonexty', fillcolor ="rgba(255, 0, 0, 0.2)"))
+        fig.add_trace(go.Scatter(x=time_fibo[-periodo_fibonacci:].reset_index()['date'], y=time_fibo[-periodo_fibonacci:].level2, mode='lines', line_width=0.5,name='38,2%',line_color='rgb(0,128,0)',fill= 'tonexty', fillcolor ="rgba(255, 255, 0, 0.2)"))
+        fig.add_trace(go.Scatter(x=time_fibo[-periodo_fibonacci:].reset_index()['date'], y=time_fibo[-periodo_fibonacci:].level1, mode='lines', line_width=0.5,name='23,6%',line_color='rgb(128,128,128)',fill= 'tonexty', fillcolor ="rgba(0, 128, 0, 0.2)"))
+        fig.add_trace(go.Scatter(x=time_fibo[-periodo_fibonacci:].reset_index()['date'], y=time_fibo[-periodo_fibonacci:].Price_Max, mode='lines', line_width=0.5,name='0%',line_color='rgb(0,0,255)',fill= 'tonexty', fillcolor ="rgba(128, 128, 128, 0.2)"))
+
+        fig.update_layout( height=600, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+        st.plotly_chart(fig,use_container_width=True)       
+
+    # ------------------------------ GRÁFICOS DE RSI---------------------------- 
+        try:
+            
+            delta = time['close'][-periodo_RSI:].diff()
+            up, down = delta.copy(), delta.copy()
+
+            up[up < 0] = 0
+            down[down > 0] = 0
+
+            period = 14
+                
+            rUp = up.ewm(com=period - 1,  adjust=False).mean()
+            rDown = down.ewm(com=period - 1, adjust=False).mean().abs()
+
+            time['RSI_' + str(period)] = 100 - 100 / (1 + rUp / rDown)
+            time['RSI_' + str(period)].fillna(0, inplace=True)
+
+            layout = go.Layout(title=f'RSI {periodo_RSI}',xaxis=dict(title="Data"), yaxis=dict(title="%RSI"))
+            fig = go.Figure(layout = layout)
+            fig.add_trace(go.Scatter(x=time.reset_index()['date'][-periodo_RSI:], y=round(time['RSI_14'][-periodo_RSI:],2), mode='lines', line_width=3,name=f'RSI {periodo_RSI}',line_color='rgb(0,0,0)'))
+
+            fig.update_layout( height=600, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+            fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+            periodo_RSI = int(st.number_input(label='periodo RSI',value=90))
+
+            with st.expander("Entenda o gráfico de Índice de Força Relativa (RSI), clique para saber mais"):
+                st.write("""Gráfico de Índice de Força Relativa (RSI), é um indicador versátil que mede a velocidade e a mudança do movimento dos preços. O RSI pode ser usado para: Determine quando um instrumento está sobrecomprado ou sobrevendido.""")  
+                st.write('Comprar ativos que apresentem um baixo valor de RSI pode ser um bom indicador de desconto!')
+
+            st.plotly_chart(fig,use_container_width=True)     
+
+        except:
+            exit
+
+    # ------------------------------ GRÁFICOS DE pivôs---------------------------- 
+        with st.expander("Entenda o gráfico de pivôs, clique para saber mais"):
+                st.write("""O Pivot Point pode ser utilizado para calcular as possíveis zonas de suporte e resistência do ativo para o período desejado, o que ajuda a entender a pressão compradora (suporte) e a pressão vendedora (resistência).""") 
+                st.write(' Os pontos do pivô podem ser utilizados como valores de stop-loss (preço de saída com perda) ou stop-gain (preço de saída com lucro) por exemplo.') 
+
+                
+
+        periodo_pivo = int(st.number_input(label='periodo pivô',value=20))
+
+        time['PP'] = pd.Series((time['high'] + time['low'] + time['close']) /3)  
+        time['R1'] = pd.Series(2 * time['PP'] - time['low'])  
+        time['S1'] = pd.Series(2 * time['PP'] - time['high'])  
+        time['R2'] = pd.Series(time['PP'] + time['high'] - time['low'])  
+        time['S2'] = pd.Series(time['PP'] - time['high'] + time['low']) 
+
+        layout = go.Layout(title=f'Pivô',xaxis=dict(title="Data"), yaxis=dict(title="Preço"))
+        fig = go.Figure(layout = layout)
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-periodo_pivo:], y=round(time['close'][-periodo_pivo:],2), mode='lines', line_width=3,name=f'preço real',line_color='rgb(0,0,0)'))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-periodo_pivo:], y=round(time['PP'][-periodo_pivo:],2), mode='lines', line_width=1,name=f'Ponto do pivô',line_color='rgb(0,128,0)'))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-periodo_pivo:], y=round(time['R1'][-periodo_pivo:],2), mode='lines', line_width=1,name=f'Resistência 1',line_color='rgb(100,149,237)'))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-periodo_pivo:], y=round(time['S1'][-periodo_pivo:],2), mode='lines', line_width=1,name=f'Suporte 1',line_color='rgb(100,149,237)'))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-periodo_pivo:], y=round(time['R2'][-periodo_pivo:],2), mode='lines', line_width=1,name=f'Resistência 2',line_color='rgb(255,0,0)'))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-periodo_pivo:], y=round(time['S2'][-periodo_pivo:],2), mode='lines', line_width=1,name=f'Suporte 2',line_color='rgb(255,0,0)'))
+
+        fig.update_layout( height=600, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+        st.plotly_chart(fig,use_container_width=True)       
+
+    # ------------------------------ GRÁFICOS DE Bolinger---------------------------- 
+        with st.expander("Entenda o gráfico de Bolinger, clique para saber mais"):
+            st.write("""Quando o preço do ativo ultrapassa a banda superior, observamos uma tendência de alta do ativo. Por outro lado, se o preço fica abaixo da banda inferior, há então uma tendência de baixa. Entretanto, deve-se ficar atento aos sinais de força dos ativos ao ultrapassar as bandas.""") 
+
+        periodo_bolinger = int(st.number_input(label='periodo Bolinger',value=180))
+
+        time['MA20'] = time['close'].rolling(20).mean()
+        time['20 Day STD'] = time['close'].rolling(window=20).std()
+        time['Upper Band'] = time['MA20'] + (time['20 Day STD'] * 2)
+        time['Lower Band'] = time['MA20'] - (time['20 Day STD'] * 2)
+
+        layout = go.Layout(title=f'Banda de Bolinger',xaxis=dict(title="Data"), yaxis=dict(title="Preço"))
+        fig = go.Figure(layout = layout)
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-periodo_bolinger:], y=round(time['Upper Band'][-periodo_bolinger:],2), mode='lines', line_width=1,name=f'Banda superior',line_color='rgb(255,0,0)'))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-periodo_bolinger:], y=round(time['Lower Band'][-periodo_bolinger:],2), mode='lines', line_width=1,name=f'Banda inferior',line_color='rgb(255,0,0)',fill= 'tonexty', fillcolor ="rgba(255, 0, 0, 0.1)",opacity=0.2))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-periodo_bolinger:], y=round(time['close'][-periodo_bolinger:],2), mode='lines', line_width=3,name=f'preço real',line_color='rgb(0,0,0)'))
+        fig.add_trace(go.Scatter(x=time.reset_index()['date'][-periodo_bolinger:], y=round(time['MA20'][-periodo_bolinger:],2), mode='lines', line_width=2,name=f'MM 20',line_color='rgb(0,128,0)'))
+  
+        fig.update_layout( height=600, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+        st.plotly_chart(fig,use_container_width=True)   
+
+        #with st.expander("Entenda o gráfico de Previsão, clique para saber mais"):
+        #    st.write("""Previsão que leva em conta apenas o movimento gráfico histórico do ativo, porém sabemos que o preço do ativo varia por outros diversos fatores. Com isso, esse é um parâmetro apenas como expectativa caso todos os outros fatores envolvidos se mantivessem.""") 
+   
+
+    # # ------------------------------ Previsões---------------------------- 
+
+    #     st.subheader('Previsões')
+
+    #     st.write('As previsões são feitas levando em conta apenas o movimento gráfico, porém o movimento do preço de um ativo é influenciado por diversos outros fatores, com isso, deve se considerar as previsões como uma hipótese de o preço do ativo variar somente pela sua variação gráfica')
+
+    #     st.write('Previsão considerando os últimos 365 dias, pode ser entendida como uma tendência dos dados segundo o último ano')
+        
+    #     st.write('Opção de alterar a previsão: caso esteja buscando resultados a curto prazo é possível alterar o "periodo analisado" para fazer previsões apenas com base nos últimos x dias. Neste caso o movimento gráfico para trás dos dias selecionados não serão levados em conta')
+    #     periodo_analisado = int(st.number_input(label='período analisado (dias de resultados passados)',value=360))
+
+    #     st.write('Opção de alterar a previsão: possibilidade de prever resultados futuros por mais de 30 dias')
+    #     periodo_futuro = int(st.number_input(label='período futuro a prever (dias)',value=30))
+
+    #     time = time.reset_index()
+    #     time = time[['date','close']]
+    #     time.columns = ['ds','y']
+
+    #     #Modelling
+    #     m = Prophet()
+    #     m.fit(time[-periodo_analisado:])
+    #     future = m.make_future_dataframe(periods= periodo_futuro, freq='B')
+    #     forecast = m.predict(future[-periodo_futuro:])
+
+    #     from fbprophet.plot import plot_plotly, plot_components_plotly
+
+    #     fig1 = plot_plotly(m, forecast)
+    #     fig1.update_layout( height=600, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+    #     fig1.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+    #     st.plotly_chart(fig1,use_container_width=True)    
+
+    #     st.subheader('Tendência diária e semanal')
+    #     st.write('0 = segunda, 1 = terça, ... , 5 = sábado, 6 = domingo')
+    #     fig2 = m.plot_components(forecast,uncertainty = False,weekly_start=1)
+        
+
+    #     st.plotly_chart(fig2,use_container_width=True)    
+        
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        #st.write('Previsão considerando as últimas semanas, pode ser entendida como uma tendência dos dados segundo os últimos dias. Leva em consideração diversos fatores como: Índice de força relativa RSI, oscilador estocástico %K, Indicador Willian %R além do movimento gráfico dos últimos dias')
+
+        #predict = stocker.predict.tomorrow(nome_do_ativo)
+
+        #st.write('Previsão para o dia:',f'{predict[2]}','é que a ação feche no valor de: R$',f'{predict[0]}')
+
+        #preço_ontem= round(time['y'][-1:].values[0],2)
+        #if predict[0] < preço_ontem:
+            #st.write('Previsão para o dia:',f'{predict[2]}','é que a ação caia de ',f'{preço_ontem}', 'para valor de: R$ ',f'{predict[0]}')
+        #else:
+            #st.write('Previsão para o dia:',f'{predict[2]}','é que a ação suba de ',f'{preço_ontem}', 'para valor de: R$ ',f'{predict[0]}')
+                        

pag2.py

@@ -0,0 +1,278 @@
+from multiprocessing import Value
+import matplotlib
+matplotlib.use('Agg')
+
+import streamlit as st
+from yahooquery import Ticker
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+import datetime as dt 
+from collections import OrderedDict
+
+import style as style
+
+
+
+import scrap as scraping
+
+def flatten(d):
+    '''
+    Flatten an OrderedDict object
+    '''
+    result = OrderedDict()
+    for k, v in d.items():
+        if isinstance(v, dict):
+            result.update(flatten(v))
+        else:
+            result[k] = v
+    return result
+
+
+def comparacao_ativos():
+        #código para ativar bootstrap css
+        st.markdown(
+        """
+        <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+        <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
+        """,unsafe_allow_html=True
+        )  
+        
+        col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+        with col2:   
+                st.title('Comparação de ativos')
+                st.subheader('Escolha 4 ativos para comparar')
+                codigo_nome = pd.read_excel('data/classification_b3.xlsx')
+                nome_do_ativo1 = st.selectbox('Nome do 1º ativo', (codigo_nome['TICKER']),key=1 )
+                nome_do_ativo2 = st.selectbox('Nome do 2º ativo', (codigo_nome['TICKER']),key=2)
+                nome_do_ativo3 = st.selectbox('Nome do 3º ativo', (codigo_nome['TICKER']),key=3 )
+                nome_do_ativo4 = st.selectbox('Nome do 4º ativo', (codigo_nome['TICKER']),key=4 )
+                style.space(1)
+                
+        if nome_do_ativo4 != "":
+                st.subheader('Analisando os dados')
+                nome_do_ativo1 = str(nome_do_ativo1 + '.SA').upper()
+                nome_do_ativo2 = str(nome_do_ativo2 + '.SA').upper()
+                nome_do_ativo3 = str(nome_do_ativo3 + '.SA').upper()
+                nome_do_ativo4 = str(nome_do_ativo4 + '.SA').upper()
+                
+                df = Ticker([nome_do_ativo1,nome_do_ativo2,nome_do_ativo3,nome_do_ativo4],country='Brazil')
+                time = df.history( start='2020-01-01', end = (dt.datetime.today() + dt.timedelta(days=1)).strftime(format='20%y-%m-%d'))
+                lista = scraping.get_data()
+                todos = pd.DataFrame(flatten(lista).keys()).transpose()
+                todos.columns = todos.iloc[0]
+
+                for i in range(len(lista)):
+                        todos = pd.concat([todos,pd.DataFrame(lista[i]).transpose()])
+
+                todos = todos.iloc[1:]
+
+                
+                todos['P/L'] = todos['P/L'].str.replace('.','')
+                todos['DY'] = todos['DY'].str.replace('%','')
+                todos['Liq.2m.'] = todos['Liq.2m.'].str.replace('.','')
+                todos['Pat.Liq'] = todos['Pat.Liq'].str.replace('.','')
+                todos = todos.replace(',','.', regex=True)
+                todos = todos.apply(pd.to_numeric,errors='ignore').round(2)
+                todos.rename(columns={'cotacao': 'Cotação'}, inplace=True)
+                comparar = todos.loc[todos.index.isin([nome_do_ativo1[:5],nome_do_ativo2[:5],nome_do_ativo3[:5],nome_do_ativo4[:5]])]
+                
+                st.dataframe(comparar)
+                # st.dataframe(comparar.style.format({"Cotação": "{:.2f}", "P/L": "{:.2f}", "P/VP": "{:.2f}", "P/Ativo": "{:.2f}"
+                # , "P/EBIT": "{:.2f}", "P/Ativ.Circ.Liq.": "{:.2f}", "EBITDA": "{:.2f}", "Liq.Corr.": "{:.2f}", "Liq.2m.": "{:.2f}"
+                # , "Pat.Liq": "{:.2f}", "Div.Brut/Pat.": "{:.2f}"                
+                #       }))
+
+
+        # ------------------------------ INÍCIO Comparação DY ---------------
+
+                col1, col2 = st.columns([0.5,0.5])   
+                with col1:   
+                        layout = go.Layout(title="DY",xaxis=dict(title="Ativo"), yaxis=dict(title="DY %"))
+                        fig = go.Figure(layout = layout)
+                        fig.add_trace(go.Bar(x=comparar.sort_values('DY',ascending=True).index, y=comparar.sort_values('DY',ascending=True)['DY'] ))
+                        fig.update_layout( height=500, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+                        st.plotly_chart(fig,use_container_width=True)   
+
+        # ------------------------------ INÍCIO Comparação P/L ---------------
+                with col2: 
+                        layout = go.Layout(title="P/L",xaxis=dict(title="Ativo"), yaxis=dict(title="P/L"))
+                        fig = go.Figure(layout = layout)
+                        fig.add_trace(go.Bar(x=comparar.sort_values('P/L',ascending=True).index, y=comparar.sort_values('P/L',ascending=True)['P/L'] ))
+                        fig.update_layout( height=500, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+                        st.plotly_chart(fig,use_container_width=True)   
+
+        # ------------------------------ INÍCIO Comparação P/V---------------
+                with col1:  
+                        layout = go.Layout(title="P/VP",xaxis=dict(title="Ativo"), yaxis=dict(title="P/VP"))
+                        fig = go.Figure(layout = layout)
+                        fig.add_trace(go.Bar(x=comparar.sort_values('P/VP',ascending=True).index, y=comparar.sort_values('P/VP',ascending=True)['P/VP'] ))
+                        fig.update_layout( height=500, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+                        st.plotly_chart(fig,use_container_width=True)   
+
+        # ------------------------------ INÍCIO Comparação P/L * P/VP---------------
+
+                with col2: 
+                        layout = go.Layout(title="P/L X P/VP",xaxis=dict(title="Ativo"), yaxis=dict(title="P/L X P/VP"))
+                        fig = go.Figure(layout = layout)
+                        fig.add_trace(go.Bar(x=comparar.index, y=comparar['P/L'] * comparar['P/VP'] ))
+                        fig.update_layout( height=500, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+                        st.plotly_chart(fig,use_container_width=True)   
+
+        # ------------------------------ GRÁFICOS DE retorno acumulado---------------------------- 
+
+                periodo_inicio = int(st.number_input(label='periodo retorno acumulado',value=360))
+
+                ret = time.reset_index()
+                layout = go.Layout(title="Retorno acumulado",xaxis=dict(title="Data"), yaxis=dict(title="Retorno"))
+                fig = go.Figure(layout = layout)
+                for i in range(len(ret['symbol'].unique())):
+                        fig.add_trace(go.Scatter(x=ret.loc[ret['symbol']==ret['symbol'].unique()[i]][-periodo_inicio:]['date'], y=ret.loc[ret['symbol']==ret['symbol'].unique()[i]][-periodo_inicio:]['close'].pct_change().cumsum(),mode='lines',name=ret.reset_index()['symbol'].unique()[i]))
+
+                        fig.update_layout( height=500, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+                st.plotly_chart(fig,use_container_width=True)   
+
+        # ------------------------------ GRÁFICOS DE MÉDIAS MÓVEIS 50---------------------------- 
+
+                rolling_50  = time['close'].rolling(window=50)
+                rolling_mean_50 = rolling_50.mean()
+                rolling_mean_50 = pd.DataFrame(rolling_mean_50.reset_index())
+                # mm50 = time.reset_index()
+
+
+                layout = go.Layout(title="MÉDIAS MÓVEIS 50",xaxis=dict(title="Data"), yaxis=dict(title="Preço R$"))
+                fig = go.Figure(layout = layout)
+                for i in range(len(rolling_mean_50['symbol'].unique())):
+                        fig.add_trace(go.Scatter(x=rolling_mean_50.loc[rolling_mean_50['symbol']==rolling_mean_50['symbol'].unique()[i]]['date'], y=rolling_mean_50.loc[rolling_mean_50['symbol']==rolling_mean_50['symbol'].unique()[i]]['close'],mode='lines',name=time.reset_index()['symbol'].unique()[i]))
+
+                        fig.update_layout( height=500, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+                st.plotly_chart(fig,use_container_width=True)   
+
+        # ------------------------------ GRÁFICOS DE MÉDIAS MÓVEIS 20---------------------------- 
+
+                rolling_50  = time['close'].rolling(window=20)
+                rolling_mean_50 = rolling_50.mean()
+                rolling_mean_50 = pd.DataFrame(rolling_mean_50.reset_index())
+                # mm50 = time.reset_index()
+
+
+                layout = go.Layout(title="MÉDIAS MÓVEIS 20",xaxis=dict(title="Data"), yaxis=dict(title="Preço R$"))
+                fig = go.Figure(layout = layout)
+                for i in range(len(rolling_mean_50['symbol'].unique())):
+                        fig.add_trace(go.Scatter(x=rolling_mean_50.loc[rolling_mean_50['symbol']==rolling_mean_50['symbol'].unique()[i]]['date'], y=rolling_mean_50.loc[rolling_mean_50['symbol']==rolling_mean_50['symbol'].unique()[i]]['close'],mode='lines',name=time.reset_index()['symbol'].unique()[i]))
+
+                        fig.update_layout( height=500, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+                st.plotly_chart(fig,use_container_width=True)   
+
+        # ------------------------------ GRÁFICOS DE volatilidade--------------------------- 
+                col1, col2 = st.columns([0.5,0.5])   
+                with col1:
+                        TRADING_DAYS = 360
+                        returns = np.log(time['close']/time['close'].shift(1))
+                        returns.fillna(0, inplace=True)
+                        volatility = returns.rolling(window=TRADING_DAYS).std()*np.sqrt(TRADING_DAYS)
+                        vol = pd.DataFrame(volatility).reset_index()
+                        vol = vol.dropna()
+
+                        layout = go.Layout(title=f"Volatilidade",xaxis=dict(title="Data"), yaxis=dict(title="Volatilidade"))
+                        fig = go.Figure(layout = layout)
+                        for i in range(len(vol['symbol'].unique())):
+                                fig.add_trace(go.Scatter(x=vol.loc[vol['symbol']==vol['symbol'].unique()[i]]['date'], y=vol.loc[vol['symbol']==vol['symbol'].unique()[i]]['close'],name=vol['symbol'].unique()[i] ))
+                                fig.update_layout( height=500, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                                fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+                        st.plotly_chart(fig,use_container_width=True)   
+
+        # ------------------------------ GRÁFICOS DE sharpe_ratio--------------------------- 
+                with col2:
+                        sharpe_ratio = returns.mean()/volatility
+                        sharpe = pd.DataFrame(sharpe_ratio).reset_index()
+                        sharpe = sharpe.dropna()
+
+                        layout = go.Layout(title=f"SHARP (Risco / Volatilidade)",xaxis=dict(title="Data"), yaxis=dict(title="Sharp"))
+                        fig = go.Figure(layout = layout)
+                        for i in range(len(sharpe['symbol'].unique())):
+                                fig.add_trace(go.Scatter(x=sharpe.loc[sharpe['symbol']==sharpe['symbol'].unique()[i]]['date'], y=sharpe.loc[sharpe['symbol']==sharpe['symbol'].unique()[i]]['close'],name=sharpe['symbol'].unique()[i] ))
+                                fig.update_layout( height=500, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                                fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+                        st.plotly_chart(fig,use_container_width=True)   
+
+        # ------------------------------ GRÁFICOS DE correlação-------------------------- 
+                try:
+
+                        time = time.reset_index()
+                        time = time[['symbol','date','close']]
+                        df_1 = time.loc[time['symbol'] == time['symbol'].unique()[0]]
+                        df_1 = df_1.set_index('date')
+                        df_1.columns = df_1.columns.values + '-' + df_1.symbol.unique() 
+                        df_1.drop(df_1.columns[0],axis=1,inplace=True)
+                        df_2 = time.loc[time['symbol'] == time['symbol'].unique()[1]]
+                        df_2 = df_2.set_index('date')
+                        df_2.columns = df_2.columns.values + '-' + df_2.symbol.unique() 
+                        df_2.drop(df_2.columns[0],axis=1,inplace=True)
+                        df_3 = time.loc[time['symbol'] == time['symbol'].unique()[2]]
+                        df_3 = df_3.set_index('date')
+                        df_3.columns = df_3.columns.values + '-' + df_3.symbol.unique() 
+                        df_3.drop(df_3.columns[0],axis=1,inplace=True)
+                        df_4 = time.loc[time['symbol'] == time['symbol'].unique()[3]]
+                        df_4 = df_4.set_index('date')
+                        df_4.columns = df_4.columns.values + '-' + df_4.symbol.unique() 
+                        df_4.drop(df_4.columns[0],axis=1,inplace=True)
+
+                        merged = pd.merge(pd.merge(pd.merge(df_1,df_2,left_on=df_1.index,right_on=df_2.index,how='left'),df_3,left_on='key_0',right_on=df_3.index,how='left'),df_4,left_on='key_0',right_on=df_4.index,how='left').rename({'key_0':'date'},axis=1).set_index('date')
+
+                        retscomp = merged.pct_change()
+
+                
+                        #plt.figure(figsize=(10,8))
+
+                        #sns.heatmap(retscomp.corr(),annot=True)
+                        #st.set_option('deprecation.showPyplotGlobalUse', False)
+                        #st.pyplot()
+
+                        import plotly.express as px
+
+                        df = px.data.medals_wide(indexed=True)
+                        fig = px.imshow(retscomp.corr(),color_continuous_scale='YlOrRd',labels=dict(x="Correlação"))
+                        #fig.update_layout(autosize=False,width=1200,height=800, paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)')
+                        fig.update_layout( height=500, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                        fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+                        fig.update_xaxes(side="top")
+
+                        st.plotly_chart(fig,use_container_width=True)   
+                except:
+                        exit
+
+        # ------------------------------ GRÁFICOS DE mapa de risco-------------------------- 
+
+                map = returns.reset_index()
+                layout = go.Layout(title=f"Mapa de Risco x Retorno",xaxis=dict(title="Retorno esperado"), yaxis=dict(title="Risco"))
+                fig = go.Figure(layout = layout)
+                for i in range(len(map['symbol'].unique())):
+                        fig.add_trace(go.Scatter(x=[map.loc[map['symbol']==map['symbol'].unique()[i]]['close'].mean() * 100], y=[map.loc[map['symbol']==map['symbol'].unique()[i]]['close'].std() * 100],name=map['symbol'].unique()[i],marker=dict(size=30)))
+                #fig.add_trace(go.Scatter(x=[map['close'].mean()], y=[map['close'].std()],text=map['symbol'].unique()))
+                fig.update_xaxes(zeroline=True, zerolinewidth=2, zerolinecolor='Red')#, range=[-0.005, 0.01])
+                fig.update_yaxes(zeroline=True, zerolinewidth=2, zerolinecolor='Red')#, range=[-0.01, 0.1])
+                fig.update_traces(textposition='top center')
+                #fig.update_layout(autosize=False,width=800,height=600, paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)')
+
+                fig.update_layout( height=500, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+                st.plotly_chart(fig,use_container_width=True)   
+

pag3.py

@@ -0,0 +1,124 @@
+import matplotlib
+matplotlib.use('Agg')
+
+import streamlit as st
+import pandas as pd
+import numpy as np
+from collections import OrderedDict
+
+import scrap as scraping
+
+from st_aggrid import AgGrid
+
+
+
+def flatten(d):
+    '''
+    Flatten an OrderedDict object
+    '''
+    result = OrderedDict()
+    for k, v in d.items(): 
+        if isinstance(v, dict):
+            result.update(flatten(v)) 
+        else:
+            result[k] = v
+    return result
+
+def descobrir_ativos():
+        #código para ativar bootstrap css
+        st.markdown(
+        """
+        <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+        <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
+        """,unsafe_allow_html=True
+        )  
+
+        col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+        with col2:                        
+            st.title('Analisar ativos com filtros e recomendações fundamentalistas')
+        st.title("")
+
+        st.subheader('Médias dos principais setores, subsetores e segmentos')
+
+        codigo_nome = pd.read_excel('data/classification_b3.xlsx')
+
+        lista = scraping.get_data()
+        todos = pd.DataFrame(flatten(lista).keys()).transpose() 
+        todos.columns = todos.iloc[0]
+
+        for i in range(len(lista)):
+          todos = pd.concat([todos,pd.DataFrame(lista[i]).transpose()])
+
+        todos = todos.iloc[1:]
+        todos = todos.reset_index()
+
+        
+
+        #tratamentos
+        todos['P/L'] = todos['P/L'].str.replace('.','')
+        todos['DY'] = todos['DY'].apply(lambda x: x[:-1])
+        todos['Cresc.5a %'] = todos['Cresc.5a'].apply(lambda x: x[:-1]).str.replace('.','').str.replace(',','.').astype(float)
+        todos['ROE'] = todos['ROE'].apply(lambda x: x[:-1]).str.replace('.','').str.replace(',','.').astype(float)
+        todos['Pat.Liq'] = todos['Pat.Liq'].str.replace('.','')
+        todos = todos.replace(',','.', regex=True)
+        todos = todos.apply(pd.to_numeric,errors='ignore')
+        todos.rename(columns={'cotacao': 'Cotação'}, inplace=True)
+        todos.rename(columns={'index': 'Código'}, inplace=True)
+
+        
+
+        #criação colunas
+        todos['VPA'] = todos['Cotação'] / todos['P/VP']
+        todos['Lucro Líquido'] = (todos['ROE'] /100 ) * 1159400000
+        todos['Quantidade de ações'] = 1159400000 / todos['VPA']
+        todos['LPA'] = todos['Lucro Líquido'] / todos['Quantidade de ações']
+        todos['DPA'] = todos['Cotação'] * (todos['DY'] / 100)
+        todos['Payout'] = todos['DPA'] / todos['LPA']
+        todos['Expectativa de crescimento'] = (1 - todos['Payout']) * todos['ROE']
+        todos['Valuation Bazin'] = todos['DPA'] / 0.06
+        todos['Desconto Bazin'] = (todos['Valuation Bazin'] - todos['Cotação']) / todos['Valuation Bazin']
+        todos['Valuation Graham'] = (22.5 * todos['LPA'] * todos['VPA']) ** 0.5
+        todos['Desconto Graham'] = (todos['Valuation Graham'] - todos['Cotação']) / todos['Valuation Graham']
+
+        todos = todos.fillna(0)
+
+        merged = pd.merge(todos,codigo_nome,on='Código', how="left")
+        merged.replace([np.inf, -np.inf], 0, inplace=True)
+
+        #group
+        col1, col2, col3 = st.columns([1,1,1])   
+        with col1:   
+            grouped_setor = merged.groupby('Setor').mean()
+            st.dataframe(grouped_setor[['Expectativa de crescimento','Desconto Graham', 'Desconto Bazin']].sort_values('Expectativa de crescimento', ascending=False).reset_index())
+        
+        with col2:   
+            grouped_subsetor = merged.groupby('Subsetor').mean()
+            st.dataframe(grouped_subsetor[['Expectativa de crescimento','Desconto Graham', 'Desconto Bazin']].sort_values('Expectativa de crescimento', ascending=False).reset_index())
+        
+        with col3:   
+            grouped_subsetor = merged.groupby('Segmento').mean()
+            st.dataframe(grouped_subsetor[['Expectativa de crescimento','Desconto Graham', 'Desconto Bazin']].sort_values('Expectativa de crescimento', ascending=False).reset_index())
+
+        
+
+        #filter
+        col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+        st.title('')
+        
+        with col2:   
+            st.write('Aplique alguns filtros na tabela')
+            exp_min = float(st.number_input(label='Expectativa de crescimento >',value=10,step=5))
+            desc_bazin = int(st.number_input(label='Desconto Bazin >',value=0.3,step=0.1))
+            desc_graham = float(st.number_input(label='Desconto Graham >',value=0.3,step=0.1))
+
+        filtred = merged.loc[(merged['Expectativa de crescimento']>= exp_min) & (merged['Desconto Bazin']>= desc_bazin) & (merged['Desconto Graham']>= desc_graham) & (merged['Desconto Bazin']!= 0)& (merged['Desconto Graham']!= 0)]
+        filtred = filtred.sort_values('Expectativa de crescimento',ascending=False)
+
+
+
+        #st.dataframe(merged[['Código','Cotação', 'Pat.Liq', 'Expectativa de crescimento','Desconto Bazin', 'Desconto Graham','Nome',	'Setor','Subsetor',	'Segmento']])
+        AgGrid(filtred[['Código','Cotação', 'Lucro Líquido', 'Expectativa de crescimento','Desconto Bazin', 'Desconto Graham','Nome',	'Setor','Subsetor',	'Segmento']].round(2))
+
+
+
+            

pag4.py

@@ -0,0 +1,176 @@
+import matplotlib
+matplotlib.use('Agg')
+
+import streamlit as st
+import pandas as pd
+import datetime as dt 
+from yahooquery import Ticker
+import plotly.graph_objects as go
+
+from collections import OrderedDict
+
+import matplotlib
+
+import scrap as scraping
+
+def flatten(d):
+    '''
+    Flatten an OrderedDict object
+    '''
+    result = OrderedDict()
+    for k, v in d.items():
+        if isinstance(v, dict):
+            result.update(flatten(v))
+        else:
+            result[k] = v
+    return result
+
+def rastreador():
+        #código para ativar bootstrap css
+        st.markdown(
+        """
+        <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+        <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
+        """,unsafe_allow_html=True
+        )  
+        
+        col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+        with col2:   
+          
+          st.title('Rastreador de oportunidades por setup')
+          
+          st.expander('Este rastreador identifica oportunidades para swing trade vasculhando as principais ações listadas na B3, o filtro consiste em encontrar ativos que tenham médias móveis exponenciais de 9 e 72 cruzadas para cima')
+          
+          st.subheader('Aplique alguns filtros para acelerar o rastreador')
+          st.write('Serão rastreadas apenas as ações listadas na tabela filtrada abaixo')
+
+          PVP_máximo = float(st.number_input(label='PVP máximo',value=1.0))
+          Patr_liq_min = int(st.number_input(label='Patrimônio líquido mínimo',value=1000000000))
+          cotacao_max = float(st.number_input(label='Cotação máxima',value=100))
+          
+
+          lista = scraping.get_data()
+          todos = pd.DataFrame(flatten(lista).keys()).transpose()
+          todos.columns = todos.iloc[0]
+          for i in range(len(lista)):
+            todos = pd.concat([todos,pd.DataFrame(lista[i]).transpose()])
+          
+          todos = todos.iloc[1:]
+          todos = todos.replace(',','.', regex=True)
+          todos = todos.apply(pd.to_numeric,errors='ignore').round(2)
+          todos['Pat.Liq'] = todos['Pat.Liq'].str.replace(r"[^0-9]+", '').replace('.','').replace(',','').replace('-','').astype(float)
+
+          todos = todos.loc[(todos['P/VP']<= PVP_máximo) & (todos['Pat.Liq']>= Patr_liq_min) & (todos['cotacao']<= cotacao_max)]
+          show = todos.reset_index()
+        st.dataframe(show)
+
+        st.subheader('Setup')
+        col1, col2,col3 = st.columns([0.1,0.4,0.1]) 
+        with col2:  
+          st.checkbox('Médias móveis exponenciais de 9 e 72 cruzadas para cima')
+
+
+
+
+        if st.button("Iniciar rastreador"):
+
+          # lista = scraping.get_data()
+          # todos = pd.DataFrame(flatten(lista).keys()).transpose()
+          # todos.columns = todos.iloc[0]
+                    
+          # for i in range(len(lista)):
+          #   todos = pd.concat([todos,pd.DataFrame(lista[i]).transpose()])
+          
+          # todos = todos.iloc[1:]
+          # todos = todos.replace(',','.', regex=True)
+          # todos = todos.apply(pd.to_numeric,errors='ignore').round(2)
+          # todos['Pat.Liq'] = todos['Pat.Liq'].str.replace(r"[^0-9]+", '').replace('.','').replace(',','').replace('-','').astype(float)
+          # todos = todos.loc[(todos['P/VP']<= PVP_máximo) & (todos['Pat.Liq']>= Patr_liq_min) & (todos['cotacao']<= cotacao_max)]
+          
+          
+          start = (dt.datetime.today() + dt.timedelta(days=-300)).strftime(format='20%y-%m-%d')
+          dia_limite = (dt.datetime.today() + dt.timedelta(days=-30)).strftime(format='20%y-%m-%d')
+
+
+          with st.expander("Aguarde estamos vasculhando todas as ações da bolsa (Mantenha esta barra minimizada)!"):
+              save = []
+              #for i in range(len(tudo)):
+              for i in range(len(todos)):
+                try:
+
+                  #nome_do_ativo = str(tudo.iloc[i][0] + '.SA')
+                  nome_do_ativo = str(todos.index[i] + '.SA')
+                  #filtra todos que cruzaram média nos últimos 50 dias pelo menos
+                  try:
+                    df = Ticker(nome_do_ativo ,country='Brazil')
+                    time = df.history( start= start )
+                    rolling_9  = time['close'].rolling(window=9)
+                    rolling_mean_9 = rolling_9.mean().round(1)
+
+                    rolling_72  = time['close'].rolling(window=72)
+                    rolling_mean_72 = rolling_72.mean().round(1)
+                    time['MM9'] = rolling_mean_9.fillna(0)
+                    time['MM72'] = rolling_mean_72.fillna(0)
+                    time['cruzamento'] =  time['MM9'] - time['MM72']
+                    buy = time.tail(50).loc[(time.tail(50)['cruzamento']==0)]
+                  except:
+                    exit
+
+
+                except:
+                  exit
+
+
+                if buy.empty == False:
+                  try:
+                    #filtra todo mundo que tem a MM 72 > que a MM 9 e quem tem volume do último dia > 5000  
+                    if time['MM72'].iloc[-1] < time['MM9'].iloc[-1] and  time.tail(1)['volume'][0] > 10000:
+                      save.append(buy.index[0][0])
+                      print(buy.index[0][0])
+                      #layout = go.Layout(title="Resultados",xaxis=dict(title="Data"), yaxis=dict(title="Preço R$"))
+                      #fig = go.Figure(layout = layout)
+                      #fig.add_trace(go.Candlestick(x=time.reset_index()['date'][-50:], open=time['open'][-50:],high=time['high'][-50:],low=time['low'][-50:],close=time['close'][-50:]))
+                      #fig.update_layout(autosize=False,width=1000,height=800,)
+                      #fig.show()
+                      #print()
+                    else:
+                      continue
+                  except:         
+                    exit
+
+                else:
+                  exit
+            
+              
+          st.dataframe(save)
+          save = pd.DataFrame(save)
+          
+          from plotly.subplots import make_subplots
+          
+          
+          for i in range(len(save)):
+              df = Ticker(save.iloc[i] ,country='Brazil')
+              time = df.history( start= start )
+
+
+
+              fig = make_subplots(rows=2, cols=1, shared_xaxes=True, 
+              vertical_spacing=0.03, subplot_titles=(st.write(save.iloc[i]), 'Volume'), 
+              row_width=[0.2, 0.7])
+
+              # Plot OHLC on 1st row
+              fig.add_trace(go.Candlestick(x=time.reset_index()['date'][-90:],
+                          open=time['open'][-90:], high=time['high'][-90:],
+                          low=time['low'][-90:], close=time['close'][-90:], name="OHLC"), 
+                          row=1, col=1)            
+
+              # Bar trace for volumes on 2nd row without legend
+              fig.add_trace(go.Bar(x=time.reset_index()['date'][-90:], y=time['volume'][-90:], showlegend=False), row=2, col=1)
+
+              # Do not show OHLC's rangeslider plot 
+              fig.update(layout_xaxis_rangeslider_visible=False)
+              #fig.update_layout(autosize=False,width=800,height=800, paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)')
+              fig.update_layout(height=600, showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') #width=800 ,
+              fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+
+              st.plotly_chart(fig,use_container_width=True)    

pag5.py

@@ -0,0 +1,532 @@
+import matplotlib
+matplotlib.use('Agg')
+
+import streamlit as st
+
+
+import pandas as pd
+from PIL import Image
+import plotly.graph_objects as go
+import numpy as np
+import yfinance as yf
+import datetime as dt 
+from collections import OrderedDict
+from sklearn.model_selection import train_test_split
+from sklearn.ensemble import RandomForestRegressor
+
+
+
+import uteis as uteis
+import scrap as scraping
+
+
+def flatten(d):
+    '''
+    Flatten an OrderedDict object
+    '''
+    result = OrderedDict()
+    for k, v in d.items():
+        if isinstance(v, dict):
+            result.update(flatten(v))
+        else:
+            result[k] = v
+    return result
+
+
+def analise_carteira():
+    #código para ativar bootstrap css
+    st.markdown(
+        """
+        <link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
+        <script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
+        """,unsafe_allow_html=True
+        )  
+
+    top_ativos = pd.read_excel('data/top_200.xlsx')#, index_col=0) 
+
+    col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+    with col2:                     
+        st.title('Análise de carteira e previsão de lucro')
+        st.subheader('Receba insights sobre suas operações realizadas no passado e preveja se sua próxima operação no futuro será lucrativa, ou não!')
+        st.write('Usando os dados do seu extrato histórico fornecido pelo site da B3 iremos treinar um algorítimo de inteligência artificial que será capaz de analisar suas operações passadas, mostrar padrões que te levaram ao lucro ou prejuízo, além de prever a probabilidade de lucro de uma ação caso ela seja comprada hoje por você')
+
+        menu = ["Escolha uma opção","Usar algoritmo do site","Usar os dados de minhas operações"]
+        choice = st.selectbox("Menu",menu)
+    
+    
+    if choice == "Usar os dados de minhas operações":
+        # se usuário estiver logado
+        if st.session_state['loged']:
+            #st.subheader('Faça upload aqui do seu extrato da B3')
+            col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+            with col2: 
+                with st.expander("Passo a passo de como acessar os dados no site da B3"):
+                    st.write('Acessar o site www.investidorb3.com.br')
+                    st.write('Aba Extratos > Negociação > Aplicar filtro trazendo dados do último ano > baixar extrato em formato excel')
+                    image = Image.open('images/b3.png')
+                    st.image(image, use_column_width=True)    
+
+            st.subheader('Faça upload aqui do seu extrato da B3')
+            file  = st.file_uploader('Entre com seu extrato (.xlsx)', type = 'xlsx')    
+            if file:
+                df = pd.read_excel(file)
+                lista = []
+                retirar = []
+                for i in range(len(df['Código de Negociação'])):
+                    #PEGANDO SOMENTE AÇÕES AO INVÉS DE FIIS CORRELATAS
+                    if len(df.iloc[i]['Código de Negociação']) == 5:
+                        lista.append(df.iloc[i]['Código de Negociação'])
+                    
+                    elif df.iloc[i]['Código de Negociação'][-1] == '1':
+                        retirar.append(df.iloc[i]['Código de Negociação'][-1])
+                    #PEGANDO AÇÕES FRACIONADAS E TRANSFORMANDO EM AÇÕES NORMAIS
+                    else:
+                        lista.append(df.iloc[i]['Código de Negociação'][:-1])
+
+                lista = pd.DataFrame(lista)[0].unique()
+                lista_input = []
+
+                #PEGAR DADOS HISTÓRICOS DE CADA UMA DAS AÇÕES
+                for i in range(len(lista)):
+                    
+                    lista_input.append(str(lista[i] + '.SA'))
+
+                date_year_ago = dt.datetime.today() - dt.timedelta(days=565)
+                date_year_ago = date_year_ago.strftime(format='20%y-%m-%d')
+                data = yf.download(lista_input,start=date_year_ago)
+
+                #CRIA UMA DF COM UMA LINHA PARA CADA AÇÃO
+                df_filled = pd.DataFrame(columns = ['name'])
+                df_filled['name'] = lista_input
+
+                # lógica para input de dados calculados 
+                #UTILIZA LISTA COM NOMES ÚNICOS DAS AÇÕES, DATAFRAME DA B3, DADOS HISTÓRICOS E A TABELA DE INPUT COM UMA LINHA PARA CADA AÇÃO
+                uteis.inputer_train(lista, df, data, df_filled)
+                
+                df_input = df_filled.fillna(0).replace(np.inf, 0)
+
+                st.subheader('Avaliação de carteira:')
+                st.write('Lucro Total do período avaliado: R$',round(df_input['Ganho_total'].sum(),2))
+                #st.write('Rendimento Total do período avaliado: %',round(df_input['Rendimento_total_%'].sum(),2))
+
+                df_input = df_input.loc[df_input['data_compra_1'] != 0]
+                df_input['data_compra_1'] = pd.to_datetime(df_input['data_compra_1']).copy()
+                df_ordered = df_input.sort_values('data_compra_1')
+                #ordenando e criando campo mes ano
+                df_ordered['mes/ano'] =df_ordered['data_compra_1'].astype(str).str[:-3]
+                df_grouped = df_ordered.groupby('mes/ano').agg({'Rendimento_total_%':'mean','Ganho_total':'sum'})
+                df_grouped = df_grouped.reset_index()
+                
+                #from plotly.subplots import make_subplots
+                #fig = make_subplots(rows=2, cols=1, specs=[[{"type": "scatter"}, {"type": "bar"}]], subplot_titles=("Rendimento mensal %","Lucro total mensal R$") )
+                #fig.add_trace(go.Scatter(x =df_grouped['mes/ano'],  y=df_grouped['Rendimento_total_%']), row=1, col=1)
+                #fig.add_trace(go.Bar(x =df_grouped['mes/ano'],  y=df_grouped['Ganho_total']), row=1, col=2)
+                #fig.update_layout(height=800, showlegend=False, paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)')
+                #st.plotly_chart(fig)
+
+                layout = go.Layout(title="Rendimento mensal %",xaxis=dict(title="mês/ano"), yaxis=dict(title="Rendimento total %"))
+                fig = go.Figure(layout = layout)
+                fig.add_trace(go.Scatter(x =df_grouped['mes/ano'],  y=df_grouped['Rendimento_total_%']))
+
+                fig.update_layout( height=600, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+                st.plotly_chart(fig,use_container_width=True)    
+
+                layout = go.Layout(title="Lucro total mensal R$",xaxis=dict(title="mês/ano"), yaxis=dict(title="Ganho total R$"))
+                fig = go.Figure(layout = layout)
+                fig.add_trace(go.Bar(x =df_grouped['mes/ano'],  y=df_grouped['Ganho_total']))
+
+                fig.update_layout( height=600, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+                fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+                st.plotly_chart(fig,use_container_width=True)    
+
+                #MODELAGEM
+                
+                df_ordered['lucro'] = 0
+                df_ordered.loc[df_ordered['Ganho_total'] > 0 , 'lucro'] = 1
+                df_ordered = df_ordered.fillna(0).replace(-np.inf, 0)
+
+                X = df_ordered.drop(['name', 'data_compra_1','mes/ano','Ganho_total','Rendimento_total_%','lucro','Preço_médio_comprado','Preço_médio_vendido'],axis=1)
+                y = df_ordered['lucro']
+
+                # divisão entre treino e teste 70/30
+                X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=42)
+
+                # Random Forest Regressor MVP
+                regr = RandomForestRegressor(random_state=42)
+                regr.fit(X_train,y_train)
+
+                predictions = regr.predict(X_test)
+
+                comparar = pd.DataFrame(y_test)
+                comparar['previsto'] = predictions
+                comparar['dif'] = comparar['previsto'] - comparar['lucro']
+
+                erros = len(comparar.loc[comparar['dif'] > 0.5]) + len(comparar.loc[comparar['dif'] < -0.5])
+                total = len(comparar)
+                precision_model = round(1 - (erros / total),2)
+
+                st.write('O modelo criado com os seus dados tem uma precisão de acerto de: ',precision_model * 100 ,'%')
+                st.write('Caso a precisão seja baixa ( < 65% )  é necessário mais dados para melhorar a performance do modelo, neste caso utilize nosso modelo pré treinado na opção " Testar com nossos dados" ou incremente seus dados com operações fictícias')
+
+                #trazendo features + importantes
+
+                features, rank = uteis.rank(X, y)
+
+                st.subheader('Estas variáveis são as que mais impactam nas decisões da inteligência artificial')
+                #col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+                col1, col2,col3 = st.columns([1,2,1])   
+                with col2: 
+                    #st.dataframe(rank['features'].head(10).reset_index(drop=True).T)
+                    top_features = rank['features'].head(10).reset_index(drop=True)
+                    st.table(top_features)
+
+                #fazendo previsão em toda a bolsa
+
+                #lista = scraping.get_data()
+                #todos = pd.DataFrame(flatten(lista).keys()).transpose()
+                #todos.columns = todos.iloc[0]
+                #for i in range(len(lista)): 
+                #    todos = pd.concat([todos,pd.DataFrame(lista[i]).transpose()])
+
+                #todos = todos.iloc[1:]
+                #todos['name'] = (todos.index + '.SA' )
+
+                #lista = top_ativos.copy()
+                
+
+                #PREVENDO 1 AÇÃO ESPECÍFICA
+                col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+                with col2: 
+                    st.subheader('Escolha o código de até 4 ativos específicos que deseja prever e pressione enter')  
+                    nome_do_ativo1 = st.text_input('Nome do ativo 1',value='PETR4')
+                    nome_do_ativo2 = st.text_input('Nome do ativo 2',value='VALE3')
+                    nome_do_ativo3 = st.text_input('Nome do ativo 3',value='WEGE3')
+                    nome_do_ativo4 = st.text_input('Nome do ativo 4')
+                
+                
+                if st.button('prever lucro das ações especificadas acima'):
+                    ativo1 = str(nome_do_ativo1 + '.SA').upper()
+                    ativo2 = str(nome_do_ativo2 + '.SA').upper()
+                    ativo3 = str(nome_do_ativo3 + '.SA').upper()
+                    ativo4 = str(nome_do_ativo4 + '.SA').upper()
+
+                    nome_do_ativo1 = nome_do_ativo1.upper()
+                    nome_do_ativo2 = nome_do_ativo2.upper()
+                    nome_do_ativo3 = nome_do_ativo3.upper()
+                    nome_do_ativo4 = nome_do_ativo4.upper()
+
+                    todos = pd.DataFrame(columns = ['name'])
+                    todos['name'] = [ativo1,ativo2,ativo3,ativo4]
+
+                    lista = pd.DataFrame(columns = ['name'])
+                    lista['name'] = [nome_do_ativo1,nome_do_ativo2,nome_do_ativo3,nome_do_ativo4]
+
+                    date_year_ago = dt.datetime.today() - dt.timedelta(days=300)
+                    date_year_ago = date_year_ago.strftime(format='20%y-%m-%d')
+
+
+                    data = yf.download(list(todos['name']),start=date_year_ago)
+
+                    df_filled = pd.DataFrame(columns = ['name'])
+                    df_filled['name'] = lista['name']
+
+                    df_filled['ativo'] = df_filled['name'].copy()
+                    df_filled = df_filled.set_index('ativo')
+
+                    df_filled = uteis.inputer_predict(data, df_filled)
+                    # retirar nulos e infinitos positivos
+                    df_input = df_filled.fillna(0).replace(np.inf, 0)
+                    #df_ordered = df_input.fillna(0).replace(-np.inf, 0)
+                    input_predict = df_input[list(X.columns)]
+                    # retirar nulos e infinitos negativos
+                    input_predict = input_predict.fillna(0).replace(-np.inf, 0)
+                    predictions = regr.predict(input_predict)
+                    input_predict['probabilidade de lucro'] = predictions.round(2) * 100
+
+                    st.subheader('Previsão de lucro das principais ações da bolsa')
+                    st.text('Essa previsão é feita com base nas tendências de sucesso captadas pelas suas operações')
+
+                    #col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+                    col1, col2,col3 = st.columns([1,2,1])   
+                    with col2: 
+                        st.table(input_predict['probabilidade de lucro'].sort_values(ascending=False).round(2))
+
+
+                if st.button('prever as top 200 ações de uma vez'):
+                    lista = top_ativos.copy()
+                    top_ativos['name'] =top_ativos['name'] + '.SA' 
+                    todos = top_ativos.copy()
+                    #todos = top_ativos.head(2) #RETIRAR AQUI PARA PEGAR OS TOP 200
+
+                    date_year_ago = dt.datetime.today() - dt.timedelta(days=300)
+                    date_year_ago = date_year_ago.strftime(format='20%y-%m-%d')
+
+
+                    data = yf.download(list(todos['name']),start=date_year_ago)
+
+                    df_filled = pd.DataFrame(columns = ['name'])
+                    df_filled['name'] = lista['name']
+
+                    df_filled['ativo'] = df_filled['name'].copy()
+                    df_filled = df_filled.set_index('ativo')
+
+                    #uteis.inputer_predict(data, df_filled)
+
+
+                    df_filled = uteis.inputer_predict(data, df_filled)
+                    # retirar nulos e infinitos positivos
+                    df_input = df_filled.fillna(0).replace(np.inf, 0)
+                    #df_ordered = df_input.fillna(0).replace(-np.inf, 0)
+                    input_predict = df_input[list(X.columns)]
+                    # retirar nulos e infinitos negativos
+                    input_predict = input_predict.fillna(0).replace(-np.inf, 0)
+                    predictions = regr.predict(input_predict)
+                    input_predict['probabilidade de lucro'] = predictions.round(2) * 100
+
+                    st.subheader('Previsão de lucro das principais ações da bolsa')
+                    st.text('Essa previsão é feita com base nas tendências de sucesso captadas pelas suas operações')
+                    col1, col2,col3 = st.columns([1,2,1])   
+                    with col2: 
+
+                        st.table(input_predict['probabilidade de lucro'].sort_values(ascending=False).round(2))
+
+
+        else:
+            st.warning("Faça o Login na seção Login")
+    
+
+    if choice == "Usar algoritmo do site":
+        st.subheader('As previsões feitas aqui utilizam dados de movimentação de milhares de operações para composição da inteligência artificial!')
+
+        df = pd.read_excel('data/b3_sem_resumo.xlsx')
+        lista = []
+        retirar = []
+        for i in range(len(df['Código de Negociação'])):
+            #PEGANDO SOMENTE AÇÕES AO INVÉS DE FIIS CORRELATAS
+            if len(df.iloc[i]['Código de Negociação']) == 5:
+                lista.append(df.iloc[i]['Código de Negociação'])
+            
+            elif df.iloc[i]['Código de Negociação'][-1] == '1':
+                retirar.append(df.iloc[i]['Código de Negociação'][-1])
+            #PEGANDO AÇÕES FRACIONADAS E TRANSFORMANDO EM AÇÕES NORMAIS
+            else:
+                lista.append(df.iloc[i]['Código de Negociação'][:-1])
+
+        lista = pd.DataFrame(lista)[0].unique()
+        lista_input = []
+
+        #PEGAR DADOS HISTÓRICOS DE CADA UMA DAS AÇÕES
+        for i in range(len(lista)):
+            
+            lista_input.append(str(lista[i] + '.SA'))
+
+        date_year_ago = dt.datetime.today() - dt.timedelta(days=565)
+        date_year_ago = date_year_ago.strftime(format='20%y-%m-%d')
+        data = yf.download(lista_input,start=date_year_ago)
+
+        #CRIA UMA DF COM UMA LINHA PARA CADA AÇÃO
+        df_filled = pd.DataFrame(columns = ['name'])
+        df_filled['name'] = lista_input
+
+        # lógica para input de dados calculados 
+        #UTILIZA LISTA COM NOMES ÚNICOS DAS AÇÕES, DATAFRAME DA B3, DADOS HISTÓRICOS E A TABELA DE INPUT COM UMA LINHA PARA CADA AÇÃO
+        uteis.inputer_train(lista, df, data, df_filled)
+        
+        df_input = df_filled.fillna(0).replace(np.inf, 0)
+
+        # st.subheader('Avaliação de carteira:')
+        # st.write('Lucro Total do período avaliado: R$',round(df_input['Ganho_total'].sum(),2))
+        # #st.write('Rendimento Total do período avaliado: %',round(df_input['Rendimento_total_%'].sum(),2))
+
+        df_input = df_input.loc[df_input['data_compra_1'] != 0]
+        df_input['data_compra_1'] = pd.to_datetime(df_input['data_compra_1']).copy()
+        df_ordered = df_input.sort_values('data_compra_1')
+        #ordenando e criando campo mes ano
+        df_ordered['mes/ano'] =df_ordered['data_compra_1'].astype(str).str[:-3]
+        df_grouped = df_ordered.groupby('mes/ano').agg({'Rendimento_total_%':'mean','Ganho_total':'sum'})
+        df_grouped = df_grouped.reset_index()
+        
+        #from plotly.subplots import make_subplots
+        #fig = make_subplots(rows=2, cols=1, specs=[[{"type": "scatter"}, {"type": "bar"}]], subplot_titles=("Rendimento mensal %","Lucro total mensal R$") )
+        #fig.add_trace(go.Scatter(x =df_grouped['mes/ano'],  y=df_grouped['Rendimento_total_%']), row=1, col=1)
+        #fig.add_trace(go.Bar(x =df_grouped['mes/ano'],  y=df_grouped['Ganho_total']), row=1, col=2)
+        #fig.update_layout(height=800, showlegend=False, paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)')
+        #st.plotly_chart(fig)
+
+        # layout = go.Layout(title="Rendimento mensal %",xaxis=dict(title="mês/ano"), yaxis=dict(title="Rendimento total %"))
+        # fig = go.Figure(layout = layout)
+        # fig.add_trace(go.Scatter(x =df_grouped['mes/ano'],  y=df_grouped['Rendimento_total_%']))
+
+        # fig.update_layout( height=600, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+        # fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+        # st.plotly_chart(fig,use_container_width=True)    
+
+        # layout = go.Layout(title="Lucro total mensal R$",xaxis=dict(title="mês/ano"), yaxis=dict(title="Ganho total R$"))
+        # fig = go.Figure(layout = layout)
+        # fig.add_trace(go.Bar(x =df_grouped['mes/ano'],  y=df_grouped['Ganho_total']))
+
+        # fig.update_layout( height=600, width=800 ,showlegend=False, paper_bgcolor='rgba(255,255,255,0.9)', plot_bgcolor='rgba(255,255,255,0.9)') 
+        # fig.update_yaxes(showgrid=True, gridwidth=0.1, gridcolor = 'rgb(240,238,238)')
+        # st.plotly_chart(fig,use_container_width=True)    
+
+        #MODELAGEM
+        
+        df_ordered['lucro'] = 0
+        df_ordered.loc[df_ordered['Ganho_total'] > 0 , 'lucro'] = 1
+        df_ordered = df_ordered.fillna(0).replace(-np.inf, 0)
+
+        X = df_ordered.drop(['name', 'data_compra_1','mes/ano','Ganho_total','Rendimento_total_%','lucro','Preço_médio_comprado','Preço_médio_vendido'],axis=1)
+        y = df_ordered['lucro']
+
+        # divisão entre treino e teste 70/30
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.30, random_state=42)
+
+        # Random Forest Regressor MVP
+        regr = RandomForestRegressor(random_state=42)
+        regr.fit(X_train,y_train)
+
+        predictions = regr.predict(X_test)
+
+        comparar = pd.DataFrame(y_test)
+        comparar['previsto'] = predictions
+        comparar['dif'] = comparar['previsto'] - comparar['lucro']
+
+        erros = len(comparar.loc[comparar['dif'] > 0.5]) + len(comparar.loc[comparar['dif'] < -0.5])
+        total = len(comparar)
+        precision_model = round(1 - (erros / total),2)
+
+        st.write('O modelo utilizado tem uma precisão de acerto de: ',precision_model * 100 ,'%')
+   
+        #trazendo features + importantes
+
+        features, rank = uteis.rank(X, y)
+
+        st.subheader('Estas variáveis são as que mais impactam nas decisões desta inteligência artificial')
+        #col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+        col1, col2,col3 = st.columns([1,2,1])   
+        with col2: 
+            #st.dataframe(rank['features'].head(10).reset_index(drop=True).T)
+            top_features = rank['features'].head(10).reset_index(drop=True)
+            st.table(top_features)
+
+        #fazendo previsão em toda a bolsa
+
+        #lista = scraping.get_data()
+        #todos = pd.DataFrame(flatten(lista).keys()).transpose()
+        #todos.columns = todos.iloc[0]
+        #for i in range(len(lista)): 
+        #    todos = pd.concat([todos,pd.DataFrame(lista[i]).transpose()])
+
+        #todos = todos.iloc[1:]
+        #todos['name'] = (todos.index + '.SA' )
+
+        #lista = top_ativos.copy()
+        
+
+        #PREVENDO 1 AÇÃO ESPECÍFICA
+        col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+        with col2: 
+            st.subheader('Escolha o código de até 4 ativos específicos que deseja prever e pressione enter')  
+            nome_do_ativo1 = st.text_input('Nome do ativo 1',value='PETR4')
+            nome_do_ativo2 = st.text_input('Nome do ativo 2',value='VALE3')
+            nome_do_ativo3 = st.text_input('Nome do ativo 3',value='WEGE3')
+            nome_do_ativo4 = st.text_input('Nome do ativo 4')
+        
+        
+        if st.button('prever lucro das ações especificadas acima'):
+            ativo1 = str(nome_do_ativo1 + '.SA').upper()
+            ativo2 = str(nome_do_ativo2 + '.SA').upper()
+            ativo3 = str(nome_do_ativo3 + '.SA').upper()
+            ativo4 = str(nome_do_ativo4 + '.SA').upper()
+
+            nome_do_ativo1 = nome_do_ativo1.upper()
+            nome_do_ativo2 = nome_do_ativo2.upper()
+            nome_do_ativo3 = nome_do_ativo3.upper()
+            nome_do_ativo4 = nome_do_ativo4.upper()
+
+            todos = pd.DataFrame(columns = ['name'])
+            todos['name'] = [ativo1,ativo2,ativo3,ativo4]
+
+            lista = pd.DataFrame(columns = ['name'])
+            lista['name'] = [nome_do_ativo1,nome_do_ativo2,nome_do_ativo3,nome_do_ativo4]
+
+            date_year_ago = dt.datetime.today() - dt.timedelta(days=300)
+            date_year_ago = date_year_ago.strftime(format='20%y-%m-%d')
+
+
+            data = yf.download(list(todos['name']),start=date_year_ago)
+
+            df_filled = pd.DataFrame(columns = ['name'])
+            df_filled['name'] = lista['name']
+
+            df_filled['ativo'] = df_filled['name'].copy()
+            df_filled = df_filled.set_index('ativo')
+
+            df_filled = uteis.inputer_predict(data, df_filled)
+            # retirar nulos e infinitos positivos
+            df_input = df_filled.fillna(0).replace(np.inf, 0)
+            #df_ordered = df_input.fillna(0).replace(-np.inf, 0)
+            input_predict = df_input[list(X.columns)]
+            # retirar nulos e infinitos negativos
+            input_predict = input_predict.fillna(0).replace(-np.inf, 0)
+            predictions = regr.predict(input_predict)
+            input_predict['probabilidade de lucro'] = predictions.round(2) * 100
+
+            st.subheader('Previsão de lucro das principais ações da bolsa')
+            st.text('Essa previsão é feita com base nas tendências de sucesso captadas pelo algoritmo do explorador de ativos')
+
+            #col1, col2,col3 = st.columns([0.1,0.4,0.1])   
+            col1, col2,col3 = st.columns([1,2,1])   
+            with col2: 
+                st.table(input_predict['probabilidade de lucro'].sort_values(ascending=False).round(2))
+
+
+        if st.button('prever as top 200 ações de uma vez'):
+            lista = top_ativos.copy()
+            top_ativos['name'] =top_ativos['name'] + '.SA' 
+            todos = top_ativos.copy()
+            #todos = top_ativos.head(2) #RETIRAR AQUI PARA PEGAR OS TOP 200
+
+            date_year_ago = dt.datetime.today() - dt.timedelta(days=300)
+            date_year_ago = date_year_ago.strftime(format='20%y-%m-%d')
+
+
+            data = yf.download(list(todos['name']),start=date_year_ago)
+
+            df_filled = pd.DataFrame(columns = ['name'])
+            df_filled['name'] = lista['name']
+
+            df_filled['ativo'] = df_filled['name'].copy()
+            df_filled = df_filled.set_index('ativo')
+
+            #uteis.inputer_predict(data, df_filled)
+
+
+            df_filled = uteis.inputer_predict(data, df_filled)
+            # retirar nulos e infinitos positivos
+            df_input = df_filled.fillna(0).replace(np.inf, 0)
+            #df_ordered = df_input.fillna(0).replace(-np.inf, 0)
+            input_predict = df_input[list(X.columns)]
+            # retirar nulos e infinitos negativos
+            input_predict = input_predict.fillna(0).replace(-np.inf, 0)
+            predictions = regr.predict(input_predict)
+            input_predict['probabilidade de lucro'] = predictions.round(2) * 100
+
+            st.subheader('Previsão de lucro das principais ações da bolsa')
+            st.text('Essa previsão é feita com base nas tendências de sucesso captadas pelas suas operações')
+            col1, col2,col3 = st.columns([1,2,1])   
+            with col2: 
+
+                st.table(input_predict['probabilidade de lucro'].sort_values(ascending=False).round(2))
+
+
+            
+
+
+
+
+
+
+
+        

requirements.txt

@@ -0,0 +1,128 @@
+altair==4.2.0
+argon2-cffi==21.3.0
+argon2-cffi-bindings==21.2.0
+asttokens==2.0.5
+async-generator==1.10
+attrs==21.4.0
+backcall==0.2.0
+beautifulsoup4==4.11.1
+bleach==5.0.0
+blinker==1.4
+cachetools==5.2.0
+cffi==1.15.0
+charset-normalizer==2.0.12
+click==8.1.3
+colorama==0.4.5
+commonmark==0.9.1
+cryptography==37.0.2
+cycler==0.11.0
+debugpy==1.6.0
+decorator==5.1.1
+defusedxml==0.7.1
+entrypoints==0.4
+et-xmlfile==1.1.0
+executing==0.8.3
+fastjsonschema==2.15.3
+fonttools==4.33.3
+gitdb==4.0.9
+GitPython==3.1.27
+h11==0.13.0
+idna==3.3
+importlib-metadata==4.12.0
+ipykernel==6.15.0
+ipywidgets==7.7.1
+jedi==0.18.1
+Jinja2==3.1.2
+joblib==1.1.0
+jsonschema==4.6.0
+jupyter-client==7.3.4
+jupyter-core==4.10.0
+jupyterlab-pygments==0.2.2
+jupyterlab-widgets==1.1.1
+kiwisolver==1.4.3
+lxml==4.9.0
+MarkupSafe==2.1.1
+matplotlib==3.5.2
+matplotlib-inline==0.1.3
+mistune==0.8.4
+multitasking==0.0.10
+nbclient==0.6.4
+nbconvert==6.5.0
+nbformat==5.4.0
+nest-asyncio==1.5.5
+notebook==6.4.12
+numpy==1.23.0
+openpyxl==3.0.10
+outcome==1.2.0
+packaging==21.3
+pandas==1.2
+pandocfilters==1.5.0
+parso==0.8.3
+pickleshare==0.7.5
+Pillow==9.1.1
+plotly==5.9.0
+prometheus-client==0.14.1
+prompt-toolkit==3.0.29
+protobuf==3.20.1
+psutil==5.9.1
+pure-eval==0.2.2
+pyarrow==8.0.0
+pycparser==2.21
+pydeck==0.7.1
+Pygments==2.12.0
+pymongo==4.1.1
+Pympler==1.0.1
+pyOpenSSL==22.0.0
+pyparsing==3.0.9
+pyrsistent==0.18.1
+PySocks==1.7.1
+python-dateutil==2.8.2
+python-dotenv==0.19.2
+pytz==2022.1
+pytz-deprecation-shim==0.1.0.post0
+pyzmq==23.2.0
+requests==2.28.0
+requests-futures==1.0.0
+rich==12.4.4
+scikit-learn==1.1.1
+scipy==1.8.1
+selenium==4.3.0
+semver==2.13.0
+Send2Trash==1.8.0
+simplejson==3.17.6
+six==1.16.0
+sklearn==0.0
+smmap==5.0.0
+sniffio==1.2.0
+sortedcontainers==2.4.0
+soupsieve==2.3.2.post1
+stack-data==0.3.0
+streamlit==1.10.0
+streamlit-aggrid==0.2.3.post2
+streamlit-option-menu==0.3.2
+tenacity==8.0.1
+terminado==0.15.0
+threadpoolctl==3.1.0
+tinycss2==1.1.1
+toml==0.10.2
+toolz==0.11.2
+tornado==6.1
+tqdm==4.64.0
+traitlets==5.3.0
+trio==0.21.0
+trio-websocket==0.9.2
+typing_extensions==4.2.0
+tzdata==2022.1
+tzlocal==4.2
+urllib3==1.26.9
+validators==0.20.0
+watchdog==2.1.9
+wcwidth==0.2.5
+webdriver-manager==3.7.1
+webencodings==0.5.1
+widgetsnbextension==3.6.1
+wincertstore==0.2
+wsproto==1.1.0
+yahooquery==2.2.15
+yfinance==0.1.72
+zipp==3.8.0

scrap.py

@@ -0,0 +1,245 @@
+from selenium import webdriver
+from webdriver_manager.chrome import ChromeDriverManager
+from time import sleep
+from tqdm.notebook import tqdm
+#from selenium.webdriver.chrome.options import Options
+import time
+import sys
+import requests
+
+import http.cookiejar
+import time
+import lxml
+import re
+import urllib.request
+import json
+import ast
+import datetime
+
+from pymongo import MongoClient
+
+from datetime import datetime
+from lxml.html import fragment_fromstring
+
+from collections import OrderedDict
+
+import urllib.parse
+
+
+
+
+def get_data(*args, **kwargs):
+    class AppURLopener(urllib.request.FancyURLopener):
+      version = "Mozilla/5.0"
+
+    opener = AppURLopener()
+    response = opener.open('http://httpbin.org/user-agent')
+
+    url = 'http://www.fundamentus.com.br/resultado.php'
+    cj = http.cookiejar.CookieJar()
+    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cj))
+
+    opener.addheaders = [('User-agent', 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.3'),
+                        ('Accept', 'text/html, text/plain, text/css, text/sgml, */*;q=0.01')                                                             
+                        ]
+
+    #opener.addheaders = [('User-agent', 'Mozilla/5.0 (Windows; U; Windows NT 6.1; rv:2.2) Gecko/20110201'),
+    #                     ('Accept', 'text/html, text/plain, text/css, text/sgml, */*;q=0.01')]
+
+    # Aqui estão os parâmetros de busca das ações
+    # Estão em branco para que retorne todas as disponíveis
+    data = {'pl_min':'','pl_max':'','pvp_min':'','pvp_max' :'','psr_min':'','psr_max':'','divy_min':'','divy_max':'',            'pativos_min':'','pativos_max':'','pcapgiro_min':'','pcapgiro_max':'','pebit_min':'','pebit_max':'', 'fgrah_min':'',
+            'fgrah_max':'', 'firma_ebit_min':'', 'firma_ebit_max':'','margemebit_min':'','margemebit_max':'',            'margemliq_min':'','margemliq_max':'', 'liqcorr_min':'','liqcorr_max':'','roic_min':'','roic_max':'','roe_min':'',            'roe_max':'','liq_min':'','liq_max':'','patrim_min':'','patrim_max':'','divbruta_min':'','divbruta_max':'',         'tx_cresc_rec_min':'','tx_cresc_rec_max':'','setor':'','negociada':'ON','ordem':'1','x':'28','y':'16'}
+
+    with opener.open(url, urllib.parse.urlencode(data).encode('UTF-8')) as link:
+        content = link.read().decode('ISO-8859-1')
+
+    pattern = re.compile('<table id="resultado".*</table>', re.DOTALL)
+    reg = re.findall(pattern, content)[0]
+    page = fragment_fromstring(reg)
+    lista = OrderedDict()
+
+
+    stocks = page.xpath('tbody')[0].findall("tr")
+
+    todos = []
+    for i in range(0, len(stocks)):
+        lista[i] = {
+            stocks[i].getchildren()[0][0].getchildren()[0].text: {
+                'cotacao': stocks[i].getchildren()[1].text,
+               'P/L': stocks[i].getchildren()[2].text,
+               'P/VP': stocks[i].getchildren()[3].text,
+               'PSR': stocks[i].getchildren()[4].text,
+               'DY': stocks[i].getchildren()[5].text,
+               'P/Ativo': stocks[i].getchildren()[6].text,
+               'P/Cap.Giro': stocks[i].getchildren()[7].text,
+               'P/EBIT': stocks[i].getchildren()[8].text,
+               'P/Ativ.Circ.Liq.': stocks[i].getchildren()[9].text,
+               'EV/EBIT': stocks[i].getchildren()[10].text,
+               'EBITDA': stocks[i].getchildren()[11].text,
+               'Mrg. Ebit': stocks[i].getchildren()[12].text,
+               'Mrg.Liq.': stocks[i].getchildren()[13].text,
+               'Liq.Corr.': stocks[i].getchildren()[14].text,
+               'ROIC': stocks[i].getchildren()[15].text,
+               'ROE': stocks[i].getchildren()[16].text,
+               'Liq.2m.': stocks[i].getchildren()[17].text,
+               'Pat.Liq': stocks[i].getchildren()[18].text,
+               'Div.Brut/Pat.': stocks[i].getchildren()[19].text,
+               'Cresc.5a': stocks[i].getchildren()[20].text
+               }
+            }
+
+    return lista
+
+def get_specific_data(stock):
+    class AppURLopener(urllib.request.FancyURLopener):
+      version = "Mozilla/5.0"
+
+    opener = AppURLopener()
+    response = opener.open('http://httpbin.org/user-agent')
+
+    url = "http://www.fundamentus.com.br/detalhes.php?papel=" + stock
+    cj = http.cookiejar.CookieJar()
+    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cj))
+    
+    opener.addheaders = [('User-agent', 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.3'),
+                        ('Accept', 'text/html, text/plain, text/css, text/sgml, */*;q=0.01')                                                             
+                        ]
+    
+    
+    
+    
+    
+    #opener.addheaders = [('User-agent', 'Mozilla/5.0 (Windows; U; Windows NT 6.1; rv:2.2) Gecko/20110201'),
+    #                     ('Accept', 'text/html, text/plain, text/css, text/sgml, */*;q=0.01')]
+    
+    # Get data from site
+    link = opener.open(url, urllib.parse.urlencode({}).encode('UTF-8'))
+    content = link.read().decode('ISO-8859-1')
+
+    # Get all table instances
+    pattern = re.compile('<table class="w728">.*</table>', re.DOTALL)
+    reg = re.findall(pattern, content)[0]
+    reg = "<div>" + reg + "</div>"
+    page = fragment_fromstring(reg)
+    all_data = {}
+
+    # There is 5 tables with tr, I will get all trs
+    all_trs = []
+    all_tables = page.xpath("table")
+
+    for i in range(0, len(all_tables)):
+        all_trs = all_trs + all_tables[i].findall("tr")
+
+    # Run through all the trs and get the label and the
+    # data for each line
+    for tr_index in range(0, len(all_trs)):
+        tr = all_trs[tr_index]
+        # Get into td
+        all_tds = tr.getchildren()
+        for td_index in range(0, len(all_tds)):
+            td = all_tds[td_index]
+
+            label = ""
+            data = ""
+
+            # The page has tds with contents and some 
+            # other with not
+            if (td.get("class").find("label") != -1):
+                # We have a label
+                for span in td.getchildren():
+                    if (span.get("class").find("txt") != -1):
+                        label = span.text
+
+                # If we did find a label we have to look 
+                # for a value 
+                if (label and len(label) > 0):
+                    next_td = all_tds[td_index + 1]
+
+                    if (next_td.get("class").find("data") != -1):
+                        # We have a data
+                        for span in next_td.getchildren():
+                            if (span.get("class").find("txt") != -1):
+                                if (span.text):
+                                    data = span.text
+                                else:
+                                    # If it is a link
+                                    span_children = span.getchildren()
+                                    if (span_children and len(span_children) > 0):
+                                        data = span_children[0].text
+
+                                # Include into dict
+                                all_data[label] = data
+
+                                # Erase it
+                                label = ""
+                                data = ""
+
+    return all_data
+
+
+
+
+def coletar_scrap():
+    sys.path.insert(0,'/usr/lib/chromium-browser/chromedriver')
+    URL = 'https://statusinvest.com.br/acoes/busca-avancada'
+    #output = 'busca-avancada.csv'
+
+    #if path.exists(output):
+    #    os.remove(output)
+
+    #chrome_options = Options()
+    #chrome_options.binary_location = GOOGLE_CHROME_BIN
+    #chrome_options.add_argument('--disable-gpu')
+    #chrome_options.add_argument('--no-sandbox')
+    #driver = webdriver.Chrome(executable_path=CHROMEDRIVER_PATH, chrome_options=chrome_options)
+
+    #driver = webdriver.Chrome('chromedriver/chromedriver.exe')
+
+    #chrome_options = webdriver.ChromeOptions()
+    #chrome_options.add_argument('--headless')
+    #chrome_options.add_argument('--no-sandbox')
+    #chrome_options.add_argument('--disable-dev-shm-usage')
+    #driver = webdriver.Chrome('chromedriver',chrome_options=chrome_options)
+
+    gChromeOptions = webdriver.ChromeOptions()
+    gChromeOptions.add_argument("window-size=1920x1480")
+    gChromeOptions.add_argument("disable-dev-shm-usage")
+    driver = webdriver.Chrome(
+        chrome_options=gChromeOptions, executable_path=ChromeDriverManager().install()
+    )
+    
+    #driver = webdriver.Chrome(ChromeDriverManager(chrome_type=ChromeType.GOOGLE).install())
+    #driver.get(URL)
+    driver.get(URL)
+    sleep(5)
+
+    button_buscar = driver.find_element_by_xpath('//div/button[contains(@class,"find")]')
+
+    button_buscar.click()
+    sleep(5)
+
+    button_skip = driver.find_element_by_xpath('//div/button[contains(@class,"btn-close")]')
+
+    button_skip.click()
+    sleep(5)
+
+    button_download = driver.find_element_by_xpath('//div/a[contains(@class, "btn-download")]')
+    button_download.click()
+    sleep(1)
+    
+    #if path.exists(output):
+               
+
+    df = pd.read_csv('busca-avancada.csv', sep=';', decimal=',', thousands='.')
+    driver.close()
+    return df
+
+
+def scrap_fundamentus():
+    url  = 'http://www.fundamentus.com.br/resultado.php'
+    headers = {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'}
+    result = requests.get(url, headers=headers)
+    df = pd.read_html(result.content)[0]
+    
+    return df

scripts/scrap.py

@@ -0,0 +1,234 @@
+from selenium import webdriver
+from webdriver_manager.chrome import ChromeDriverManager
+from time import sleep
+#from tqdm.notebook import tqdm
+#from selenium.webdriver.chrome.options import Options
+import sys
+import requests
+import http.cookiejar
+import re
+import urllib.request
+from lxml.html import fragment_fromstring
+from collections import OrderedDict
+import urllib.parse
+import pandas as pd
+
+
+
+
+
+def get_data(*args, **kwargs):
+    class AppURLopener(urllib.request.FancyURLopener):
+      version = "Mozilla/5.0"
+
+    opener = AppURLopener()
+    response = opener.open('http://httpbin.org/user-agent')
+
+    url = 'http://www.fundamentus.com.br/resultado.php'
+    cj = http.cookiejar.CookieJar()
+    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cj))
+
+    opener.addheaders = [('User-agent', 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.3'),
+                        ('Accept', 'text/html, text/plain, text/css, text/sgml, */*;q=0.01')                                                             
+                        ]
+
+    #opener.addheaders = [('User-agent', 'Mozilla/5.0 (Windows; U; Windows NT 6.1; rv:2.2) Gecko/20110201'),
+    #                     ('Accept', 'text/html, text/plain, text/css, text/sgml, */*;q=0.01')]
+
+    # Aqui estão os parâmetros de busca das ações
+    # Estão em branco para que retorne todas as disponíveis
+    data = {'pl_min':'','pl_max':'','pvp_min':'','pvp_max' :'','psr_min':'','psr_max':'','divy_min':'','divy_max':'',            'pativos_min':'','pativos_max':'','pcapgiro_min':'','pcapgiro_max':'','pebit_min':'','pebit_max':'', 'fgrah_min':'',
+            'fgrah_max':'', 'firma_ebit_min':'', 'firma_ebit_max':'','margemebit_min':'','margemebit_max':'',            'margemliq_min':'','margemliq_max':'', 'liqcorr_min':'','liqcorr_max':'','roic_min':'','roic_max':'','roe_min':'',            'roe_max':'','liq_min':'','liq_max':'','patrim_min':'','patrim_max':'','divbruta_min':'','divbruta_max':'',         'tx_cresc_rec_min':'','tx_cresc_rec_max':'','setor':'','negociada':'ON','ordem':'1','x':'28','y':'16'}
+
+    with opener.open(url, urllib.parse.urlencode(data).encode('UTF-8')) as link:
+        content = link.read().decode('ISO-8859-1')
+
+    pattern = re.compile('<table id="resultado".*</table>', re.DOTALL)
+    reg = re.findall(pattern, content)[0]
+    page = fragment_fromstring(reg)
+    lista = OrderedDict()
+
+
+    stocks = page.xpath('tbody')[0].findall("tr")
+
+    todos = []
+    for i in range(0, len(stocks)):
+        lista[i] = {
+            stocks[i].getchildren()[0][0].getchildren()[0].text: {
+                'cotacao': stocks[i].getchildren()[1].text,
+               'P/L': stocks[i].getchildren()[2].text,
+               'P/VP': stocks[i].getchildren()[3].text,
+               'PSR': stocks[i].getchildren()[4].text,
+               'DY': stocks[i].getchildren()[5].text,
+               'P/Ativo': stocks[i].getchildren()[6].text,
+               'P/Cap.Giro': stocks[i].getchildren()[7].text,
+               'P/EBIT': stocks[i].getchildren()[8].text,
+               'P/Ativ.Circ.Liq.': stocks[i].getchildren()[9].text,
+               'EV/EBIT': stocks[i].getchildren()[10].text,
+               'EBITDA': stocks[i].getchildren()[11].text,
+               'Mrg. Ebit': stocks[i].getchildren()[12].text,
+               'Mrg.Liq.': stocks[i].getchildren()[13].text,
+               'Liq.Corr.': stocks[i].getchildren()[14].text,
+               'ROIC': stocks[i].getchildren()[15].text,
+               'ROE': stocks[i].getchildren()[16].text,
+               'Liq.2m.': stocks[i].getchildren()[17].text,
+               'Pat.Liq': stocks[i].getchildren()[18].text,
+               'Div.Brut/Pat.': stocks[i].getchildren()[19].text,
+               'Cresc.5a': stocks[i].getchildren()[20].text
+               }
+            }
+
+    return lista
+
+def get_specific_data(stock):
+    class AppURLopener(urllib.request.FancyURLopener):
+      version = "Mozilla/5.0"
+
+    opener = AppURLopener()
+    response = opener.open('http://httpbin.org/user-agent')
+
+    url = "http://www.fundamentus.com.br/detalhes.php?papel=" + stock
+    cj = http.cookiejar.CookieJar()
+    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(cj))
+    
+    opener.addheaders = [('User-agent', 'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.3'),
+                        ('Accept', 'text/html, text/plain, text/css, text/sgml, */*;q=0.01')                                                             
+                        ]
+    
+    
+    
+    
+    
+    #opener.addheaders = [('User-agent', 'Mozilla/5.0 (Windows; U; Windows NT 6.1; rv:2.2) Gecko/20110201'),
+    #                     ('Accept', 'text/html, text/plain, text/css, text/sgml, */*;q=0.01')]
+    
+    # Get data from site
+    link = opener.open(url, urllib.parse.urlencode({}).encode('UTF-8'))
+    content = link.read().decode('ISO-8859-1')
+
+    # Get all table instances
+    pattern = re.compile('<table class="w728">.*</table>', re.DOTALL)
+    reg = re.findall(pattern, content)[0]
+    reg = "<div>" + reg + "</div>"
+    page = fragment_fromstring(reg)
+    all_data = {}
+
+    # There is 5 tables with tr, I will get all trs
+    all_trs = []
+    all_tables = page.xpath("table")
+
+    for i in range(0, len(all_tables)):
+        all_trs = all_trs + all_tables[i].findall("tr")
+
+    # Run through all the trs and get the label and the
+    # data for each line
+    for tr_index in range(0, len(all_trs)):
+        tr = all_trs[tr_index]
+        # Get into td
+        all_tds = tr.getchildren()
+        for td_index in range(0, len(all_tds)):
+            td = all_tds[td_index]
+
+            label = ""
+            data = ""
+
+            # The page has tds with contents and some 
+            # other with not
+            if (td.get("class").find("label") != -1):
+                # We have a label
+                for span in td.getchildren():
+                    if (span.get("class").find("txt") != -1):
+                        label = span.text
+
+                # If we did find a label we have to look 
+                # for a value 
+                if (label and len(label) > 0):
+                    next_td = all_tds[td_index + 1]
+
+                    if (next_td.get("class").find("data") != -1):
+                        # We have a data
+                        for span in next_td.getchildren():
+                            if (span.get("class").find("txt") != -1):
+                                if (span.text):
+                                    data = span.text
+                                else:
+                                    # If it is a link
+                                    span_children = span.getchildren()
+                                    if (span_children and len(span_children) > 0):
+                                        data = span_children[0].text
+
+                                # Include into dict
+                                all_data[label] = data
+
+                                # Erase it
+                                label = ""
+                                data = ""
+
+    return all_data
+
+
+
+
+def coletar_scrap():
+    sys.path.insert(0,'/usr/lib/chromium-browser/chromedriver')
+    URL = 'https://statusinvest.com.br/acoes/busca-avancada'
+    #output = 'busca-avancada.csv'
+
+    #if path.exists(output):
+    #    os.remove(output)
+
+    #chrome_options = Options()
+    #chrome_options.binary_location = GOOGLE_CHROME_BIN
+    #chrome_options.add_argument('--disable-gpu')
+    #chrome_options.add_argument('--no-sandbox')
+    #driver = webdriver.Chrome(executable_path=CHROMEDRIVER_PATH, chrome_options=chrome_options)
+
+    #driver = webdriver.Chrome('chromedriver/chromedriver.exe')
+
+    #chrome_options = webdriver.ChromeOptions()
+    #chrome_options.add_argument('--headless')
+    #chrome_options.add_argument('--no-sandbox')
+    #chrome_options.add_argument('--disable-dev-shm-usage')
+    #driver = webdriver.Chrome('chromedriver',chrome_options=chrome_options)
+
+    gChromeOptions = webdriver.ChromeOptions()
+    gChromeOptions.add_argument("window-size=1920x1480")
+    gChromeOptions.add_argument("disable-dev-shm-usage")
+    driver = webdriver.Chrome(
+        chrome_options=gChromeOptions, executable_path=ChromeDriverManager().install()
+    )
+    
+    #driver = webdriver.Chrome(ChromeDriverManager(chrome_type=ChromeType.GOOGLE).install())
+    #driver.get(URL)
+    driver.get(URL)
+    sleep(5)
+
+    button_buscar = driver.find_element_by_xpath('//div/button[contains(@class,"find")]')
+
+    button_buscar.click()
+    sleep(5)
+
+    button_skip = driver.find_element_by_xpath('//div/button[contains(@class,"btn-close")]')
+
+    button_skip.click()
+    sleep(5)
+
+    button_download = driver.find_element_by_xpath('//div/a[contains(@class, "btn-download")]')
+    button_download.click()
+    sleep(1)
+    
+    #if path.exists(output):
+               
+
+    df = pd.read_csv('busca-avancada.csv', sep=';', decimal=',', thousands='.')
+    driver.close()
+    return df
+
+
+def scrap_fundamentus():
+    url  = 'http://www.fundamentus.com.br/resultado.php'
+    headers = {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 Safari/537.36'}
+    result = requests.get(url, headers=headers)
+    df = pd.read_html(result.content)[0]
+    
+    return df

setup.sh

@@ -0,0 +1,13 @@
+mkdir -p ~/.streamlit/
+
+echo "\
+[general]\n\
+email = \"lucas.vasconcelos3@gmail.com\"\n\
+" > ~/.streamlit/credentials.toml
+
+echo "\
+[server]\n\
+headless = true\n\
+enableCORS=false\n\
+port = $PORT\n\
+" > ~/.streamlit/config.toml

style.py

@@ -0,0 +1,95 @@
+import base64
+import streamlit as st
+
+from streamlit_option_menu import option_menu
+
+def get_base64(bin_file):
+    with open(bin_file, 'rb') as f:
+        data = f.read()
+    return base64.b64encode(data).decode()
+
+def set_background(png_file):
+    bin_str = get_base64(png_file)
+    page_bg_img = '''
+    <style>
+    .stApp {
+    background-image: url("data:image/png;base64,%s");
+    background-size: cover;
+    }
+    </style>
+    ''' % bin_str
+    st.markdown(page_bg_img, unsafe_allow_html=True)
+
+#esconder botões do streamlit
+def hidden_menu_and_footer():
+    hide_menu = '''
+    <style>
+    #MainMenu {
+        visibility:hidden;
+    }
+
+    footer{
+        visibility:hidden;
+    }
+
+    </style>
+    '''
+    st.markdown(hide_menu, unsafe_allow_html=True)
+
+#linha no cabeçalho branca desing
+def headerstyle():
+    st.markdown(
+    f"""
+    <nav class="navbar fixed-top navbar-light bg-white" style="color: #ffffff; padding: 0.8rem 1rem;">
+        <span class="navbar-brand mb-0 h1" " >  </span>
+    </nav>
+    """, unsafe_allow_html=True
+    )
+
+
+#espaço entre plots
+def space(tamanho):
+    if tamanho == 1:
+        st.title('')
+    if tamanho == 2:
+        st.header('') 
+    if tamanho == 3:
+        st.write('') 
+
+def sidebarwidth():
+    st.markdown(
+        """
+        <style>
+        [data-testid="stSidebar"][aria-expanded="true"] > div:first-child {
+            width: 250px;
+        }
+        [data-testid="stSidebar"][aria-expanded="false"] > div:first-child {
+            width: 250px;
+            margin-left: -500px;
+        }
+        </style>
+        """,
+        unsafe_allow_html=True,
+        )    
+
+def font_google():
+    st.markdown(
+            """
+            <style>
+    @font-face {
+    font-family: 'Roboto';
+    font-style: normal;
+    font-weight: 400;
+    src: url(https://fonts.gstatic.com/s/tangerine/v12/IurY6Y5j_oScZZow4VOxCZZM.woff2) format('woff2');
+    unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+    }
+
+        html, body, [class*="css"]  {
+        font-family: 'Roboto';
+        font-size: 48px;
+        }
+        </style>
+
+        """,
+            unsafe_allow_html=True,
+        )

style_0.css

@@ -0,0 +1,98 @@
+p{
+    color:rgb(74, 113, 152);
+    text-align: center;
+    font-size: 14px;
+    font-family: 'Bree Serif', serif;
+}
+
+
+
+/* sidebar */
+.css-ppzyts {
+    background-color: rgb(255, 255, 255);
+    background-attachment: fixed;
+    flex-shrink: 0;
+    height: 100vh;
+    overflow: auto;
+    padding: 3rem 1rem;
+    position: relative;
+    transition: margin-left 300ms ease 0s, box-shadow 300ms ease 0s;
+    width: 15rem;
+    z-index: 100;
+    margin-left: 0px;
+}
+
+
+/* botão input */
+.st-b7 {
+    width: 600px;
+    border-radius: 2.25rem;
+
+    
+}
+
+/* Plotly */
+.main-svg{
+    border-radius: 2.25rem;
+    width: 100%;
+    display: flex;
+    flex-wrap: wrap;
+    -webkit-box-flex: 1;
+    flex-grow: 1;
+    -webkit-box-align: stretch;  
+    align-items: stretch;
+}
+
+.plot-container.plotly{
+    width: 100%;
+    display: flex;
+    flex-wrap: wrap;
+    -webkit-box-flex: 1;
+    flex-grow: 1;
+    -webkit-box-align: stretch;  
+    align-items: stretch;
+
+}
+
+
+/* DataFrame style */
+.stDataFrame {
+    border-radius: 10px;
+    background: rgb(240, 238, 238);
+    background-color:#fff;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/* centralização página */
+
+/* .css-12oz5g7 {
+    flex: 1 1 0%;
+    width: 100%;
+    padding: 6rem 1rem 10rem;
+    max-width: 46rem;
+} */
+
+/* .css-18e3th9 {
+    flex: 1 1 0%;
+    width: 100%;
+    padding: 6rem 1rem 10rem;
+    min-width: auto;
+    max-width: initial;
+    text-align: center;
+    justify-content: center;
+} */

style_1.css

@@ -0,0 +1,146 @@
+p{
+    color:rgb(74, 113, 152);
+    text-align: center;
+    font-size: 14px;
+    font-family: 'Bree Serif', serif;
+}
+
+
+
+
+/* MÉTRICS KPIS STREAMLIT  */
+.css-12w0qpk.e1tzin5v2{
+    display: fixed;
+    flex-wrap: wrap;
+    -webkit-box-flex: 1;
+    flex-grow: 1;
+    -webkit-box-align: stretch;  
+    align-items: stretch;
+    gap: 1rem;
+    background-color:#fff;
+    border-radius: 2.25rem;
+    text-align: center;
+    width: 800px;
+
+}
+
+/* card conteudo  */
+
+.card-main .card-body {
+    display: fixed;
+    flex-wrap: wrap;
+    -webkit-box-flex: 1;
+    flex-grow: 1;
+    -webkit-box-align: stretch;  
+    align-items: stretch;
+    gap: 1rem;
+    background-color:#fff;
+    border-radius: 2.25rem;
+    text-align: center;
+    width: 100%;
+}
+
+/* botão input */
+.st-b7 {
+    width: 100%;
+    border-radius: 2.25rem;
+
+    
+}
+
+.css-18e3th9 {
+    flex: 1 1 0%;
+    width: 100%;
+    padding: 6rem 1rem 10rem;
+    min-width: auto;
+    max-width: initial;
+    text-align: center;
+    justify-content: center;
+    align-items: center;
+    align-content: center;
+    align-self: center;
+    vertical-align: center;
+}
+
+
+
+
+/* KPI BOOSTRAP */
+
+/* .icon {  
+float: right;
+font-size:500%;
+position: absolute;
+top:0rem;
+right:-0.3rem;
+opacity: .16;
+}
+
+
+#container
+{
+width: 800px;
+display: flex;
+}
+
+.kpi-card
+{
+overflow: hidden;
+position: relative;
+box-shadow: 1px 1px 3px rgba(0,0,0,0.75);;
+display: inline-block;
+float: left;
+padding: 1em;
+border-radius: 0.3em;
+font-family: sans-serif;  
+width: 240px;
+min-width: 180px;
+margin-left: 0.5em;
+margin-top: 0.5em;
+}
+
+.card-value {
+display: block;
+font-size: 200%;  
+font-weight: bolder;
+}
+
+.card-text {
+display:block;
+font-size: 70%;
+padding-left: 0.2em;
+} */
+
+/* Todos os cards juntos */
+/* .card-deck {
+    -webkit-box-orient: horizontal;
+    -webkit-box-direction: normal;
+    -ms-flex-flow: row wrap;
+    flex-flow: row wrap;
+    margin-right: 0px;
+    margin-left: -15px;
+    width: 430px;
+    
+}
+
+
+.card-deck .card {
+    display: -webkit-box;
+    display: -ms-flexbox;
+    display: flex;
+    -webkit-box-flex: 1;
+    -ms-flex: 1 0 0%;
+    flex: 1 0 0%;
+    -webkit-box-orient: vertical;
+    -webkit-box-direction: normal;
+    -ms-flex-direction: column;
+    flex-direction: column;
+    margin-right: 15px;
+    margin-bottom: 0;
+    margin-left: 15px;
+    border-radius: 2.25rem;
+} */
+
+
+
+

style_2.css

@@ -0,0 +1,29 @@
+p{
+    color:rgb(74, 113, 152);
+    text-align: center;
+    font-size: 14px;
+    font-family: 'Bree Serif', serif;
+}
+
+
+/* botão input */
+.st-b7 {
+    width: 100%;
+    border-radius: 2.25rem;
+
+    
+}
+
+.css-18e3th9 {
+    flex: 1 1 0%;
+    width: 100%;
+    padding: 6rem 1rem 10rem;
+    min-width: auto;
+    max-width: initial;
+    text-align: center;
+    justify-content: center;
+    align-items: center;
+    align-content: center;
+    align-self: center;
+    vertical-align: center;
+}

style_3.css

@@ -0,0 +1,29 @@
+p{
+    color:rgb(74, 113, 152);
+    text-align: center;
+    font-size: 14px;
+    font-family: 'Bree Serif', serif;
+}
+
+
+/* botão input */
+.st-b7 {
+    width: 100%;
+    border-radius: 2.25rem;
+
+    
+}
+
+.css-18e3th9 {
+    flex: 1 1 0%;
+    width: 100%;
+    padding: 6rem 1rem 10rem;
+    min-width: auto;
+    max-width: initial;
+    text-align: center;
+    justify-content: center;
+    align-items: center;
+    align-content: center;
+    align-self: center;
+    vertical-align: center;
+}

style_4.css

@@ -0,0 +1,40 @@
+p{
+    color:rgb(74, 113, 152);
+    text-align: center;
+    font-size: 14px;
+    font-family: 'Bree Serif', serif;
+}
+
+/* .css-18e3th9 {
+    flex: 1 1 0%;
+    width: 100%;
+    padding: 6rem 1rem 10rem;
+    min-width: auto;
+    max-width: initial;
+    text-align: center;
+    justify-content: center;
+} */
+
+
+
+/* botão input */
+.st-b7 {
+    width: 100%;
+    border-radius: 2.25rem;
+
+    
+}
+
+.css-18e3th9 {
+    flex: 1 1 0%;
+    width: 100%;
+    padding: 6rem 1rem 10rem;
+    min-width: auto;
+    max-width: initial;
+    text-align: center;
+    justify-content: center;
+    align-items: center;
+    align-content: center;
+    align-self: center;
+    vertical-align: center;
+}

style_5.css

@@ -0,0 +1,36 @@
+p{
+    color:rgb(74, 113, 152);
+    text-align: center;
+    font-size: 14px;
+    font-family: 'Bree Serif', serif;
+}
+
+.css-18e3th9 {
+    flex: 1 1 0%;
+    width: 100%;
+    padding: 6rem 1rem 10rem;
+    min-width: auto;
+    max-width: initial;
+    text-align: center;
+    justify-content: center;
+    align-items: center;
+    align-content: center;
+    align-self: center;
+    vertical-align: center;
+}
+
+
+/* DataFrame style */
+.stDataFrame {
+    border-radius: 10px;
+    background: rgb(240, 238, 238);
+    background-color:#fff;
+}
+
+/* botão input */
+.st-b7 {
+    width: 100%;
+    border-radius: 2.25rem;
+
+    
+}

style_login.css

@@ -0,0 +1,6 @@
+/* botão input */
+.st-b7 {
+    width: 250px;
+    border-radius: 2.25rem;
+    
+}

users.csv

@@ -0,0 +1,3 @@
+name;user;pass;email;premium
+Lucas Vasconcelos Rocha;lucasrocha;senhadosite;lucas.vasconcelos3@gmail.com;sim
+testando;teste;123;;

uteis.py

@@ -0,0 +1,485 @@
+
+#import streamlit as st
+import pandas as pd
+from sklearn.ensemble import RandomForestRegressor
+
+def rank( X, y):
+    """
+    Gets a rank of relation of features to target
+    The output is a list of combination of features order by relevance by 'RF rank'
+    
+    :param X: Train data without target
+    :param y: Target
+    
+    """
+
+    X = X
+    y = y
+    # estimators
+    rank = pd.DataFrame({'features': X.columns})
+
+
+    rfr = RandomForestRegressor(n_jobs=-1, n_estimators=50, verbose=3)
+    rfr.fit(X, y)
+    rank['RFR'] = (rfr.feature_importances_ * 100)
+
+    #print(rank.sort_values('RFR', ascending=False))
+
+    # opções de listas de features selecionadas para cada estimador
+    lista_comb_feat_RFR = []
+    #for x in range(2, 11):
+    for x in range(2, len(rank)):
+        lista_comb_feat_RFR.append(rank.sort_values('RFR', ascending=False).head(x)['features'].tolist())
+
+    return lista_comb_feat_RFR , rank.sort_values('RFR', ascending=False)
+
+#UTILIZA LISTA COM NOMES ÚNICOS DAS AÇÕES, DATAFRAME DA B3, DADOS HISTÓRICOS E A TABELA DE INPUT COM UMA LINHA PARA CADA AÇÃO
+def inputer_train(lista, df, data, df_filled):
+
+    for i in range(len(lista)):
+        if df.loc[(df['Código de Negociação'].str.contains(lista[i]))].sort_values('Tipo de Movimentação')[-1:]['Tipo de Movimentação'].item() == 'Venda':
+            
+            #Construção das variáveis
+            preco_medio_compra = df.loc[(df['Código de Negociação'].str.contains(lista[i])) & (df['Tipo de Movimentação'] == 'Compra' )]['Preço'].mean()
+            quantidade_comprada = df.loc[(df['Código de Negociação'].str.contains(lista[i])) & (df['Tipo de Movimentação'] == 'Compra' )]['Quantidade'].sum()
+            preco_medio_vendido = df.loc[(df['Código de Negociação'].str.contains(lista[i])) & (df['Tipo de Movimentação'] == 'Venda' )]['Preço'].mean()
+            quantidade_vendida = df.loc[(df['Código de Negociação'].str.contains(lista[i])) & (df['Tipo de Movimentação'] == 'Venda' )]['Quantidade'].sum()
+            
+            data_compra_1 = df.loc[(df['Código de Negociação'].str.contains(lista[i]))].sort_values('Data do Negócio')[-1:]['Data do Negócio'].item()
+            Ganho_total = (preco_medio_vendido - preco_medio_compra) * quantidade_vendida
+            rendimento_total = round(((preco_medio_vendido - preco_medio_compra) / preco_medio_vendido) * 100,2)
+            
+            #dados históricos ticker
+            dados_acao = pd.DataFrame(data.loc[ : , (['Open','High','Low','Close','Adj Close','Volume'],lista[i]+".SA")])
+            #dados_acao_filtrado = dados_acao.loc[dados_acao.index <= data_compra_1]
+            dados_acao_filtrado = dados_acao.loc[dados_acao.index <= pd.to_datetime(data_compra_1)]               
+            
+            #RENDIMENTO ULTIMOS X DIAS (ONTEM X DIA COMPARADO)
+            
+            #valor da ultima cotação
+            cotacao_last = dados_acao_filtrado['Close'][-1:][lista[i]+".SA"][0]
+            #valor cotação x dias atras
+            try:
+                cotacao_7 = dados_acao_filtrado['Close'][-7:-6][lista[i]+".SA"][0]
+                cotacao_14 = dados_acao_filtrado['Close'][-14:-13][lista[i]+".SA"][0]
+                cotacao30 = dados_acao_filtrado['Close'][-30:-29][lista[i]+".SA"][0]
+                cotacao_60 = dados_acao_filtrado['Close'][-60:-59][lista[i]+".SA"][0]
+                cotacao_90 = dados_acao_filtrado['Close'][-90:-89][lista[i]+".SA"][0]
+                #% da queda ou aumento ultimos x dias
+                crescimento_7 = round(((cotacao_last - cotacao_7) / cotacao_7) * 100,2)
+                crescimento_14 = round(((cotacao_last - cotacao_14) / cotacao_14) * 100,2)
+                crescimento_30 = round(((cotacao_last - cotacao30) / cotacao30) * 100,2)
+                crescimento_60 = round(((cotacao_last - cotacao_60) / cotacao_60) * 100,2)
+                crescimento_90 = round(((cotacao_last - cotacao_90) / cotacao_90) * 100,2)
+            
+            except:
+                exit
+
+            #CRESCIMENTO VOLUME ULTIMOS X DIAS (ONTEM X DIA COMPARADO)
+            
+            #volume do dia anterior a compra
+            volume_last = dados_acao_filtrado['Volume'][-1:][lista[i]+".SA"][0]
+            #valor cotação x dias atras
+            try:
+                volume_7 = dados_acao_filtrado['Volume'][-7:-6][lista[i]+".SA"][0]
+                volume_14 = dados_acao_filtrado['Volume'][-14:-13][lista[i]+".SA"][0]
+                volume30 = dados_acao_filtrado['Volume'][-30:-29][lista[i]+".SA"][0]
+                volume_60 = dados_acao_filtrado['Volume'][-60:-59][lista[i]+".SA"][0]
+                volume_90 = dados_acao_filtrado['Volume'][-90:-89][lista[i]+".SA"][0]
+                #% da queda ou aumento ultimos x dias
+                crescimento_vol_7 = round(((volume_last - volume_7) / volume_7) * 100,2)
+                crescimento_vol_14 = round(((volume_last - volume_14) / volume_14) * 100,2)
+                crescimento_vol_30 = round(((volume_last - volume30) / volume30) * 100,2)
+                crescimento_vol_60 = round(((volume_last - volume_60) / volume_60) * 100,2)
+                crescimento_vol_90 = round(((volume_last - volume_90) / volume_90) * 100,2)
+            
+            except:
+                exit
+                
+            #RSI
+            try:
+                delta = dados_acao_filtrado['Close'][-90:].diff()
+                up, down = delta.copy(), delta.copy()
+                up[up < 0] = 0
+                down[down > 0] = 0
+                period = 14
+                rUp = up.ewm(com=period - 1,  adjust=False).mean()
+                rDown = down.ewm(com=period - 1, adjust=False).mean().abs()
+                delta['RSI'] = 100 - 100 / (1 + rUp / rDown).fillna(0)
+                
+                rsi_0 = delta['RSI'][-1:][0]
+                rsi_7 = delta['RSI'][-7:-6][0]
+                rsi_14 = delta['RSI'][-14:-13][0]
+                rsi_30 = delta['RSI'][-30:-29][0]
+                rsi_60 = delta['RSI'][-60:-59][0]
+
+                #% da queda ou aumento ultimos x dias
+                cresc_rsi_7 = round(((rsi_0 - rsi_7) / rsi_7) * 100,2)
+                cresc_rsi_14 = round(((rsi_0 - rsi_14) / rsi_14) * 100,2)
+                cresc_rsi_30 = round(((rsi_0 - rsi_30) / rsi_30) * 100,2)
+                cresc_rsi_60 = round(((rsi_0 - rsi_60) / rsi_60) * 100,2)
+
+            except:
+                exit
+                
+            #BOLINGER
+            
+            try:
+                bolinger = dados_acao_filtrado.copy()
+                bolinger['MA20'] = dados_acao_filtrado['Close'].rolling(20).mean()
+                bolinger['20 Day STD'] = bolinger['Close'].rolling(window=20).std()
+                bolinger['Upper Band'] = bolinger['MA20'] + (bolinger['20 Day STD'] * 2)
+                bolinger['Lower Band'] = bolinger['MA20'] - (bolinger['20 Day STD'] * 2)
+
+                boolinger_up_0 = bolinger['Upper Band'][-1:][0]
+                boolinger_down_0 = bolinger['Lower Band'][-1:][0]
+                boolinger_up_7 = bolinger['Upper Band'][-7:-6][0]
+                boolinger_down_7 = bolinger['Lower Band'][-7:-6][0]
+
+                delta_bolinger_0 = round((boolinger_up_0 - boolinger_down_0) / boolinger_down_0 * 100,2)
+                cresc_bolinger_up_7 = round((boolinger_up_0 - boolinger_up_7) / boolinger_up_7 * 100,2)
+                cresc_bolinger_down_7 = round((boolinger_down_0 - boolinger_down_7) / boolinger_down_7 * 100,2)
+                
+            except:
+                exit
+                
+            
+            #MÉDIAS MOVEIS
+            try:
+                time = dados_acao_filtrado.copy()
+                rolling_9  = time['Close'].rolling(window=9)
+                rolling_mean_9 = rolling_9.mean().round(1)
+
+                rolling_20  = time['Close'].rolling(window=20)
+                rolling_mean_20 = rolling_20.mean().round(1)
+
+                rolling_72  = time['Close'].rolling(window=72)
+                rolling_mean_72 = rolling_72.mean().round(1)
+                time['MM9'] = rolling_mean_9.fillna(0)
+                time['MM20'] = rolling_mean_20.fillna(0)
+                time['MM72'] = rolling_mean_72.fillna(0)
+                time['cruzamento'] =  time['MM9'] - time['MM72']
+                buy = time.tail(50).loc[(time.tail(50)['cruzamento']==0)]
+
+                if buy.empty == False:
+                    cruzou_mm = 1
+                else:
+                    cruzou_mm = 0         
+
+                if time['MM72'].iloc[-1] < time['MM9'].iloc[-1]:
+                    direcao_cruzada_cima = 1
+                else:
+                    direcao_cruzada_cima = 0
+                    
+
+                mm9_0 = time['MM9'][-1:][0]
+                mm9_7 = time['MM9'][-7:-6][0]
+                mm9_14 = time['MM9'][-14:-13][0]
+                mm9_30 = time['MM9'][-30:-29][0]
+                mm9_60 = time['MM9'][-60:-59][0]
+                
+                mm20_0 = time['MM20'][-1:][0]
+                mm20_7 = time['MM20'][-7:-6][0]
+                mm20_14 = time['MM20'][-14:-13][0]
+                mm20_30 = time['MM20'][-30:-29][0]
+                mm20_60 = time['MM20'][-60:-59][0]
+    
+                mm72_0 = time['MM72'][-1:][0]
+                mm72_7 = time['MM72'][-7:-6][0]
+                mm72_14 = time['MM72'][-14:-13][0]
+                mm72_30 = time['MM72'][-30:-29][0]
+                mm72_60 = time['MM72'][-60:-59][0]
+                
+                #% da queda ou aumento ultimos x dias
+                cresc_mm9_7 = round(((mm9_0 - mm9_7) / mm9_7) * 100,2)
+                cresc_mm9_14 = round(((mm9_0 - mm9_14) / mm9_14) * 100,2)
+                cresc_mm9_30 = round(((mm9_0 - mm9_30) / mm9_30) * 100,2)
+                cresc_mm9_60 = round(((mm9_0 - mm9_60) / mm9_60) * 100,2)
+                
+                #% da queda ou aumento ultimos x dias
+                cresc_mm20_7 = round(((mm20_0 - mm20_7) / mm20_7) * 100,2)
+                cresc_mm20_14 = round(((mm20_0 - mm20_14) / mm20_14) * 100,2)
+                cresc_mm20_30 = round(((mm20_0 - mm20_30) / mm20_30) * 100,2)
+                cresc_mm20_60 = round(((mm20_0 - mm20_60) / mm20_60) * 100,2)
+                
+                #% da queda ou aumento ultimos x dias
+                cresc_mm72_7 = round(((mm72_0 - mm72_7) / mm72_7) * 100,2)
+                cresc_mm72_14 = round(((mm72_0 - mm72_14) / mm72_14) * 100,2)
+                cresc_mm72_30 = round(((mm72_0 - mm72_30) / mm72_30) * 100,2)
+                cresc_mm72_60 = round(((mm72_0 - mm72_60) / mm72_60) * 100,2)
+                
+            except:
+                exit
+                
+            #try:
+            #    pfizer = yf.Ticker(lista[i])
+            #    info = pfizer.info 
+
+            #    setor = info['sector']
+            #    atividade = info['industry']
+                
+            #except:
+            #    exit
+
+            try:
+            #Atribuições
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'data_compra_1'] = data_compra_1
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'Preço_médio_comprado'] = preco_medio_compra
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'Preço_médio_vendido'] = preco_medio_vendido
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'Ganho_total'] = Ganho_total
+
+                #df_filled.loc[df_filled['name'].str.contains(lista[i]),'Setor'] = setor
+                #df_filled.loc[df_filled['name'].str.contains(lista[i]),'Atividade'] = atividade
+
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_total_%'] = rendimento_total
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_ultimos_7_dias'] = crescimento_7
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_ultimos_14_dias'] = crescimento_14
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_ultimos_30_dias'] = crescimento_30
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_ultimos_60_dias'] = crescimento_60
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_ultimos_90_dias'] = crescimento_90
+
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'crescimento_vol_ultimos_7_dias'] = crescimento_vol_7
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'crescimento_vol_ultimos_14_dias'] = crescimento_vol_14
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'crescimento_vol_ultimos_30_dias'] = crescimento_vol_30
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'crescimento_vol_ultimos_60_dias'] = crescimento_vol_60
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'crescimento_vol_ultimos_90_dias'] = crescimento_vol_90
+
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'rsi'] = rsi_0
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_rsi_ultimos_7_dias'] = cresc_rsi_7
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_rsi_ultimos_14_dias'] = cresc_rsi_14
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_rsi_ultimos_30_dias'] = cresc_rsi_30
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_rsi_ultimos_60_dias'] = cresc_rsi_60
+
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'delta_bolinger_0'] = delta_bolinger_0
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_bolinger_up_7'] = cresc_bolinger_up_7
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_bolinger_down_7'] = cresc_bolinger_down_7
+
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cruzou_mm'] = cruzou_mm
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'direcao_cruzada_mm_cima'] = direcao_cruzada_cima
+
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm9_ultimos_7_dias'] = cresc_mm9_7
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm9_ultimos_14_dias'] = cresc_mm9_14
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm9_ultimos_30_dias'] = cresc_mm9_30
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm9_ultimos_60_dias'] = cresc_mm9_60
+
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm20_ultimos_7_dias'] = cresc_mm20_7
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm20_ultimos_14_dias'] = cresc_mm20_14
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm20_ultimos_30_dias'] = cresc_mm20_30
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm20_ultimos_60_dias'] = cresc_mm20_60        
+
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm72_ultimos_7_dias'] = cresc_mm72_7
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm72_ultimos_14_dias'] = cresc_mm72_14
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm72_ultimos_30_dias'] = cresc_mm72_30
+                df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm72_ultimos_60_dias'] = cresc_mm72_60
+            
+            except:
+                exit
+
+def inputer_predict(data, df_filled):
+
+    lista = list(df_filled['name'])
+    for i in range(len(df_filled)):
+        dados_acao = pd.DataFrame(data.loc[ : , (['Open','High','Low','Close','Adj Close','Volume'],lista[i]+".SA")])
+        dados_acao_filtrado = dados_acao.copy()
+        #RENDIMENTO ULTIMOS X DIAS (ONTEM X DIA COMPARADO)
+        #valor da ultima cotação
+        cotacao_last = dados_acao_filtrado['Close'][-1:][lista[i]+".SA"][0]
+        #valor cotação x dias atras
+        try:
+            cotacao_7 = dados_acao_filtrado['Close'][-7:-6][lista[i]+".SA"][0]
+            cotacao_14 = dados_acao_filtrado['Close'][-14:-13][lista[i]+".SA"][0]
+            cotacao30 = dados_acao_filtrado['Close'][-30:-29][lista[i]+".SA"][0]
+            cotacao_60 = dados_acao_filtrado['Close'][-60:-59][lista[i]+".SA"][0]
+            cotacao_90 = dados_acao_filtrado['Close'][-90:-89][lista[i]+".SA"][0]
+            #% da queda ou aumento ultimos x dias
+            crescimento_7 = round(((cotacao_last - cotacao_7) / cotacao_7) * 100,2)
+            crescimento_14 = round(((cotacao_last - cotacao_14) / cotacao_14) * 100,2)
+            crescimento_30 = round(((cotacao_last - cotacao30) / cotacao30) * 100,2)
+            crescimento_60 = round(((cotacao_last - cotacao_60) / cotacao_60) * 100,2)
+            crescimento_90 = round(((cotacao_last - cotacao_90) / cotacao_90) * 100,2)
+        except:
+            exit
+        #CRESCIMENTO VOLUME ULTIMOS X DIAS (ONTEM X DIA COMPARADO)
+        #volume do dia anterior a compra
+        volume_last = dados_acao_filtrado['Volume'][-1:][lista[i]+".SA"][0]
+        #valor cotação x dias atras
+        try:
+            volume_7 = dados_acao_filtrado['Volume'][-7:-6][lista[i]+".SA"][0]
+            volume_14 = dados_acao_filtrado['Volume'][-14:-13][lista[i]+".SA"][0]
+            volume30 = dados_acao_filtrado['Volume'][-30:-29][lista[i]+".SA"][0]
+            volume_60 = dados_acao_filtrado['Volume'][-60:-59][lista[i]+".SA"][0]
+            volume_90 = dados_acao_filtrado['Volume'][-90:-89][lista[i]+".SA"][0]
+            #% da queda ou aumento ultimos x dias
+            crescimento_vol_7 = round(((volume_last - volume_7) / volume_7) * 100,2)
+            crescimento_vol_14 = round(((volume_last - volume_14) / volume_14) * 100,2)
+            crescimento_vol_30 = round(((volume_last - volume30) / volume30) * 100,2)
+            crescimento_vol_60 = round(((volume_last - volume_60) / volume_60) * 100,2)
+            crescimento_vol_90 = round(((volume_last - volume_90) / volume_90) * 100,2)
+        except:
+            exit
+        #RSI
+        try:
+            delta = dados_acao_filtrado['Close'][-90:].diff()
+            up, down = delta.copy(), delta.copy()
+            up[up < 0] = 0
+            down[down > 0] = 0
+            period = 14
+            rUp = up.ewm(com=period - 1,  adjust=False).mean()
+            rDown = down.ewm(com=period - 1, adjust=False).mean().abs()
+            delta['RSI'] = 100 - 100 / (1 + rUp / rDown).fillna(0)
+
+            rsi_0 = delta['RSI'][-1:][0]
+            rsi_7 = delta['RSI'][-7:-6][0]
+            rsi_14 = delta['RSI'][-14:-13][0]
+            rsi_30 = delta['RSI'][-30:-29][0]
+            rsi_60 = delta['RSI'][-60:-59][0]
+
+            #% da queda ou aumento ultimos x dias
+            cresc_rsi_7 = round(((rsi_0 - rsi_7) / rsi_7) * 100,2)
+            cresc_rsi_14 = round(((rsi_0 - rsi_14) / rsi_14) * 100,2)
+            cresc_rsi_30 = round(((rsi_0 - rsi_30) / rsi_30) * 100,2)
+            cresc_rsi_60 = round(((rsi_0 - rsi_60) / rsi_60) * 100,2)
+        except:
+            exit
+        #BOLINGER
+        try:
+            bolinger = dados_acao_filtrado.copy()
+            bolinger['MA20'] = dados_acao_filtrado['Close'].rolling(20).mean()
+            bolinger['20 Day STD'] = bolinger['Close'].rolling(window=20).std()
+            bolinger['Upper Band'] = bolinger['MA20'] + (bolinger['20 Day STD'] * 2)
+            bolinger['Lower Band'] = bolinger['MA20'] - (bolinger['20 Day STD'] * 2)
+
+            boolinger_up_0 = bolinger['Upper Band'][-1:][0]
+            boolinger_down_0 = bolinger['Lower Band'][-1:][0]
+            boolinger_up_7 = bolinger['Upper Band'][-7:-6][0]
+            boolinger_down_7 = bolinger['Lower Band'][-7:-6][0]
+
+            delta_bolinger_0 = round((boolinger_up_0 - boolinger_down_0) / boolinger_down_0 * 100,2)
+            cresc_bolinger_up_7 = round((boolinger_up_0 - boolinger_up_7) / boolinger_up_7 * 100,2)
+            cresc_bolinger_down_7 = round((boolinger_down_0 - boolinger_down_7) / boolinger_down_7 * 100,2)
+        except:
+            exit
+        #MÉDIAS MOVEIS
+        try:
+            time = dados_acao_filtrado.copy()
+            rolling_9  = time['Close'].rolling(window=9)
+            rolling_mean_9 = rolling_9.mean().round(1)
+
+            rolling_20  = time['Close'].rolling(window=20)
+            rolling_mean_20 = rolling_20.mean().round(1)
+
+            rolling_72  = time['Close'].rolling(window=72)
+            rolling_mean_72 = rolling_72.mean().round(1)
+            time['MM9'] = rolling_mean_9.fillna(0)
+            time['MM20'] = rolling_mean_20.fillna(0)
+            time['MM72'] = rolling_mean_72.fillna(0)
+            time['cruzamento'] =  time['MM9'] - time['MM72']
+            buy = time.tail(50).loc[(time.tail(50)['cruzamento']==0)]
+
+            if buy.empty == False:
+                cruzou_mm = 1
+            else:
+                cruzou_mm = 0         
+
+            if time['MM72'].iloc[-1] < time['MM9'].iloc[-1]:
+                direcao_cruzada_cima = 1
+            else:
+                direcao_cruzada_cima = 0
+                
+            mm9_0 = time['MM9'][-1:][0]
+            mm9_7 = time['MM9'][-7:-6][0]
+            mm9_14 = time['MM9'][-14:-13][0]
+            mm9_30 = time['MM9'][-30:-29][0]
+            mm9_60 = time['MM9'][-60:-59][0]
+
+            mm20_0 = time['MM20'][-1:][0]
+            mm20_7 = time['MM20'][-7:-6][0]
+            mm20_14 = time['MM20'][-14:-13][0]
+            mm20_30 = time['MM20'][-30:-29][0]
+            mm20_60 = time['MM20'][-60:-59][0]
+
+            mm72_0 = time['MM72'][-1:][0]
+            mm72_7 = time['MM72'][-7:-6][0]
+            mm72_14 = time['MM72'][-14:-13][0]
+            mm72_30 = time['MM72'][-30:-29][0]
+            mm72_60 = time['MM72'][-60:-59][0]
+
+            #% da queda ou aumento ultimos x dias
+            cresc_mm9_7 = round(((mm9_0 - mm9_7) / mm9_7) * 100,2)
+            cresc_mm9_14 = round(((mm9_0 - mm9_14) / mm9_14) * 100,2)
+            cresc_mm9_30 = round(((mm9_0 - mm9_30) / mm9_30) * 100,2)
+            cresc_mm9_60 = round(((mm9_0 - mm9_60) / mm9_60) * 100,2)
+
+            #% da queda ou aumento ultimos x dias
+            cresc_mm20_7 = round(((mm20_0 - mm20_7) / mm20_7) * 100,2)
+            cresc_mm20_14 = round(((mm20_0 - mm20_14) / mm20_14) * 100,2)
+            cresc_mm20_30 = round(((mm20_0 - mm20_30) / mm20_30) * 100,2)
+            cresc_mm20_60 = round(((mm20_0 - mm20_60) / mm20_60) * 100,2)
+
+            #% da queda ou aumento ultimos x dias
+            cresc_mm72_7 = round(((mm72_0 - mm72_7) / mm72_7) * 100,2)
+            cresc_mm72_14 = round(((mm72_0 - mm72_14) / mm72_14) * 100,2)
+            cresc_mm72_30 = round(((mm72_0 - mm72_30) / mm72_30) * 100,2)
+            cresc_mm72_60 = round(((mm72_0 - mm72_60) / mm72_60) * 100,2)
+
+        except:
+            exit
+
+        try:
+
+        #Atribuições
+            #df_filled.loc[df_filled['name'].str.contains(lista[i]),'data_compra_1'] = data_compra_1
+            #df_filled.loc[df_filled['name'].str.contains(lista[i]),'Preço_médio_comprado'] = preco_medio_compra
+            #df_filled.loc[df_filled['name'].str.contains(lista[i]),'Preço_médio_vendido'] = preco_medio_vendido
+            #df_filled.loc[df_filled['name'].str.contains(lista[i]),'Ganho_total'] = Ganho_total
+
+            #df_filled.loc[df_filled['name'].str.contains(lista[i]),'Setor'] = setor
+            #df_filled.loc[df_filled['name'].str.contains(lista[i]),'Atividade'] = atividade
+
+            #df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_total_%'] = rendimento_total
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_ultimos_7_dias'] = crescimento_7
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_ultimos_14_dias'] = crescimento_14
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_ultimos_30_dias'] = crescimento_30
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_ultimos_60_dias'] = crescimento_60
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'Rendimento_ultimos_90_dias'] = crescimento_90
+
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'crescimento_vol_ultimos_7_dias'] = crescimento_vol_7
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'crescimento_vol_ultimos_14_dias'] = crescimento_vol_14
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'crescimento_vol_ultimos_30_dias'] = crescimento_vol_30
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'crescimento_vol_ultimos_60_dias'] = crescimento_vol_60
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'crescimento_vol_ultimos_90_dias'] = crescimento_vol_90
+
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'rsi'] = rsi_0
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_rsi_ultimos_7_dias'] = cresc_rsi_7
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_rsi_ultimos_14_dias'] = cresc_rsi_14
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_rsi_ultimos_30_dias'] = cresc_rsi_30
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_rsi_ultimos_60_dias'] = cresc_rsi_60
+
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'delta_bolinger_0'] = delta_bolinger_0
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_bolinger_up_7'] = cresc_bolinger_up_7
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_bolinger_down_7'] = cresc_bolinger_down_7
+
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cruzou_mm'] = cruzou_mm
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'direcao_cruzada_mm_cima'] = direcao_cruzada_cima
+
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm9_ultimos_7_dias'] = cresc_mm9_7
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm9_ultimos_14_dias'] = cresc_mm9_14
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm9_ultimos_30_dias'] = cresc_mm9_30
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm9_ultimos_60_dias'] = cresc_mm9_60
+
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm20_ultimos_7_dias'] = cresc_mm20_7
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm20_ultimos_14_dias'] = cresc_mm20_14
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm20_ultimos_30_dias'] = cresc_mm20_30
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm20_ultimos_60_dias'] = cresc_mm20_60        
+
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm72_ultimos_7_dias'] = cresc_mm72_7
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm72_ultimos_14_dias'] = cresc_mm72_14
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm72_ultimos_30_dias'] = cresc_mm72_30
+            df_filled.loc[df_filled['name'].str.contains(lista[i]),'cresc_mm72_ultimos_60_dias'] = cresc_mm72_60
+
+            
+        except:
+            exit
+        
+    return df_filled
+