index.py

import dash
from dash import Dash, html, dcc, callback, Output, Input
from dash import dash_table
import plotly.express as px

from app import app
import pandas as pd

import datetime
import requests
from io import StringIO
from datetime import date

import dash_bootstrap_components as dbc
import plotly.express as px

server = app.server

url='https://drive.google.com/file/d/1NaXOYHQFF5UO5rQr4rn8Lr3bkYMSOq4_/view?usp=sharing'
url='https://drive.google.com/uc?id=' + url.split('/')[-2]

# reading of file
df = pd.read_csv(url)

# filtering the file for more than 4 tokens
df = df[df['Headline'].str.split().str.len().gt(4)]  

df['date'] = pd.to_datetime(df['date'])

unique_domains = df['domain_folder_name'].unique()
print(unique_domains)

unique_topics = df['Topic'].unique()
print(unique_topics)

#copying a column 
df["Veículos de notícias"] = df["domain_folder_name"]

# df = df.rename(columns={df.columns[4]: "Veículos de notícias"})

df['FinBERT_label'] = df['FinBERT_label'].astype(str)
df['FinBERT_label'].replace({
    '3.0': 'positive',
    '2.0': 'neutral',
    '1.0': 'negative'
}, inplace=True)



counts = df.groupby(['date', 'Topic', 'domain_folder_name', 'FinBERT_label']).size().reset_index(name='count')
counts['count'] = counts['count'].astype('float64')
counts['rolling_mean_counts'] = counts['count'].rolling(window=30, min_periods=2).mean()

df_pos = counts[[x in ['positive'] for x in counts.FinBERT_label]]
df_neu = counts[[x in ['neutral'] for x in counts.FinBERT_label]]
df_neg = counts[[x in ['negative'] for x in counts.FinBERT_label]]


# app.layout 
tab_content_1 = dbc.Container([   
    dbc.Row([ # row 1
        dbc.Col([html.H1('Evolução temporal de sentimento em títulos de notícias')],
        className="text-center mt-3 mb-1")]),
    
    dbc.Row([ # row 2
        dbc.Label("Selecione um período (mm/dd/aaaa):", className="fw-bold")]),

    dbc.Row([ # row 3
        dcc.DatePickerRange(
            id='date-range',
            min_date_allowed=df['date'].min().date(),
            max_date_allowed=df['date'].max().date(),
            initial_visible_month=df['date'].min().date(),
            start_date=df['date'].min().date(),
            end_date=df['date'].max().date())]),

    dbc.Row([ # row 4
        dbc.Label("Escolha um tópico:", className="fw-bold")
    ]),

    dbc.Row([ # row 5
        dbc.Col(
            dcc.Dropdown(
                id="topic-selector",
                options=[
                    {"label": topic, "value": topic} for topic in unique_topics
                ],
                value="Imigrantes",  # Set the initial value
                style={"width": "50%"})


        )
    ]),
    
    dbc.Row([ # row 6
            dbc.Col(dcc.Graph(id='line-graph-1'))
    ]),

    dbc.Row([ # row 7 but needs to be updated
        dbc.Col(dcc.Graph(id="bar-graph-1"))
    ]),
    
    # html.Div(id='pie-container-1'),
    dbc.Row([ # row 9
             dbc.Col(dcc.Graph(id='pie-graph-1'),
                )
    ]),
    
    dbc.Row([ # row 7
            dbc.Label("Escolha um site de notícias:", className="fw-bold")
    ]),

    dbc.Row([ # row 8
        dbc.Col(
            dcc.Dropdown(
                id="domain-selector",
                options=[
                    {"label": domain, "value": domain} for domain in unique_domains
                ],
                value="expresso-pt",  # Set the initial value
                style={"width": "50%"})


        )
    ]),
    
     dbc.Row([ # row 9
             dbc.Col(dcc.Graph(id='line-graph-2'),
                     )
     ]),
    
    # dbc.Row([ # row 9
    #         dbc.Col(dcc.Graph(id='line-graph-2'),
    #                 )
    # ]),

    # dbc.Row([ # row 10
    #         dbc.Col(dcc.Graph(id='line-graph-3'),
    #                 )
    # ]),
    
    # dbc.Row([ # row 11
    #         dbc.Col(dcc.Graph(id='line-graph-4'),
    #                 )
    # ]),

    # html.Div(id='pie-container-2'),
     dbc.Row([ # row 9
             dbc.Col(dcc.Graph(id='pie-graph-2'),
                )
     ]),
    
    dbc.Row([ # row 9
            dbc.Col(
                dash_table.DataTable(
                    id='headlines-table',
                    columns=[
                        {"name": "Headline", "id": "Headline"},
                        {"name": "URL", "id": "url"},
                        {"name": "Date", "id": "date"},
                        {"name": "Sentiment Label", "id": "FinBERT_label"}
                    ],
                    style_table={'overflowX': 'auto'},
                    style_cell={
                        'textAlign': 'left',
                        'whiteSpace': 'normal',
                        'height': 'auto',
                        'minWidth': '180px', 'width': '180px', 'maxWidth': '180px',
                    },
                    page_current= 0,
                    page_size= 10,
                )
            )
        ])
    
])

# # Create a function to generate pie charts
# def generate_pie_chart(category):
#     labels = data[category]['labels']
#     values = data[category]['values']
#     trace = go.Pie(labels=labels, values=values)
#     layout = go.Layout(title=f'Pie Chart - {category}')
#     return dcc.Graph(
#         figure={
#             'data': [trace],
#             'layout': layout
#         }
#     )
    
# callback decorator
@app.callback(
    Output('line-graph-1', 'figure'),
    Output('bar-graph-1','figure'),
    Output('pie-graph-1', 'figure'),
    Output('line-graph-2', 'figure'),
    Output('pie-graph-2', 'figure'),
    Output('headlines-table', 'data'),
    Input("topic-selector", "value"),
    Input("domain-selector", "value"),
    Input('date-range', 'start_date'),
    Input('date-range', 'end_date')
)
def update_output(selected_topic, selected_domain, start_date, end_date):
    #log
    print("topic",selected_topic,"domain",selected_domain,"start", start_date,"date", end_date)
    
    # filter dataframes based on updated data range
    mask_1 = ((df["Topic"] == selected_topic) & (df['date'] >= start_date) & (df['date'] <= end_date))
    df_filtered = df.loc[mask_1]
    print(df_filtered.shape)
    if len(df_filtered)>0:
        #create line graphs based on filtered dataframes
        line_fig_1 = px.line(df_filtered, x="date", y="normalised results",
                         color='Veículos de notícias', title="O gráfico mostra a evolução temporal de sentimento dos títulos de notícias. Numa escala de -1 (negativo) a 1 (positivo), sendo 0 (neutro).")
    
        # Veículos de notícias
        #set x-axis title and y-axis title in line graphs
        line_fig_1.update_layout(
                       xaxis_title='Data',
                       yaxis_title='Classificação de Sentimento')
    
        #set label format on y-axis in line graphs
        line_fig_1.update_xaxes(tickformat="%b %d<br>%Y")
    
        # Bar Graph start
        grouped_df = df_filtered.groupby(['date', 'Veículos de notícias']).size().reset_index(name='occurrences')
        
        # Sort DataFrame by 'period' column
        grouped_df = grouped_df.sort_values(by='date')
        
        # Create a list of all unique media
        all_media = df_filtered['domain_folder_name'].unique()
        
        # Create a date range from Jan/2000 to the last month in the dataset
        date_range = pd.date_range(start=df_filtered['date'].min().date(), end=df_filtered['date'].max().date(), freq='MS')
        
        # Create a MultiIndex with all combinations of date_range and all_media
        idx = pd.MultiIndex.from_product([date_range, all_media], names=['date', 'Veículos de notícias'])
        
        # Reindex the DataFrame to include all periods and media
        grouped_df = grouped_df.set_index(['date', 'Veículos de notícias']).reindex(idx, fill_value=0).reset_index()
    
        bar_fig_1 = px.bar(grouped_df, x='date', y='occurrences', color='Veículos de notícias',
                 labels={'date': 'Período', 'occurrences': 'Número de notícias', 'Veículos de notícias': 'Portal'},
                 title='Número de notícias por período de tempo')
        bar_fig_1.update_xaxes(tickformat="%b %d<br>%Y")
        # Bar Graph ends
                           
        # line-fig 2 starts
        # filter dataframes based on updated data range
        # Filtering data...
        df_filtered_2 = counts[(counts['Topic'] == selected_topic) &
                             (counts['domain_folder_name'] == selected_domain) &
                             (counts['date'] >= start_date) &
                             (counts['date'] <= end_date)]
    
        # Create a date range for the selected period
        date_range = pd.date_range(start=start_date, end=end_date)
    
        # Create a DataFrame with all possible combinations of classes, topics, and dates
        all_combinations = pd.MultiIndex.from_product([['positive', 'neutral', 'negative'],
                                                       [selected_topic],
                                                       [selected_domain],
                                                       date_range],
                                                      names=['FinBERT_label', 'Topic', 'domain_folder_name', 'date'])
        df_all_combinations = pd.DataFrame(index=all_combinations).reset_index()
    
        # Merge filtered DataFrame with DataFrame of all combinations
        merged_df = pd.merge(df_all_combinations, df_filtered_2, on=['FinBERT_label', 'Topic', 'domain_folder_name', 'date'], how='left')
    
        # Fill missing values with zeros
        merged_df['count'].fillna(0, inplace=True)
        merged_df['rolling_mean_counts'].fillna(0, inplace=True)
    
        # Create line graph...
        line_fig_2 = px.line(merged_df, x="date", y="count", color="FinBERT_label",
                       line_group="FinBERT_label", title="Sentiment Over Time",
                       labels={"count": "Number of News Articles", "date": "Date"})
    
    
        # Update layout...
        line_fig_2.update_layout(xaxis_title='Date', yaxis_title='Number of News Articles',
                               xaxis=dict(tickformat="%b %d<br>%Y"))
        # line-fig 2 ends
        
        # Map original labels to their translated versions
        label_translation = {'positive': 'positivo', 'neutral': 'neutro', 'negative': 'negativo'}
        df_filtered['FinBERT_label_transformed'] = df_filtered['FinBERT_label'].map(label_translation)
        
        # Group by FinBERT_label and count occurrences
        label_counts_all = df_filtered['FinBERT_label_transformed'].value_counts()
        
        # Calculate percentage of each label
        label_percentages_all = (label_counts_all / label_counts_all.sum()) * 100
        
        # Plot general pie chart
        pie_chart_1 = px.pie(
            values=label_percentages_all,
            names=label_percentages_all.index,
            title='Distribuição Geral',
            color_discrete_sequence=['#039a4d', '#3c03f4', '#ca3919']
        )
        
        # Get unique media categories
        media_categories = df_filtered['Veículos de notícias'].unique()
        
        # Define colors for each label
        label_colors = {'positivo': '#039a4d', 'neutro': '#3c03f4', 'negativo': '#ca3919'}
                         
        # Filter DataFrame for current media category
        media_df = df_filtered[df_filtered['Veículos de notícias'] == selected_domain]
    
        # Group by FinBERT_label and count occurrences
        label_counts = media_df['FinBERT_label_transformed'].value_counts()
    
        # Calculate percentage of each label
        label_percentages = (label_counts / label_counts.sum()) * 100
    
        # Plot pie chart
        pie_chart_2 = px.pie(
            values=label_percentages,
            names=label_percentages.index,
            title=f'Distribuição para {selected_domain}',
            color_discrete_sequence=[label_colors[label] for label in label_percentages.index]
        )
        # pie_chart_2 = dcc.Graph(figure=fig)
        # pie_chart_2 = html.Div(fig,className='four columns')
       
        # Convert FinBERT_label to categorical for better sorting
        media_df['FinBERT_label'] = pd.Categorical(media_df['FinBERT_label'],
                                                      categories=['positive', 'neutral', 'negative'],
                                                      ordered=True)

        # Sort DataFrame by sentiment label and date
        data_table_1 = media_df.sort_values(by=['FinBERT_label', 'date'])
    
        return line_fig_1, bar_fig_1, pie_chart_1, line_fig_2, pie_chart_2, data_table_1.to_dict('records')
    else:
        return {'data': []},{'data': []} ,{'data': []} ,{'data': []} , {'data': []}, {'data': []}
    
    # return line_fig_1
    


# df = pd.read_csv('https://raw.githubusercontent.com/plotly/datasets/master/gapminder_unfiltered.csv')



# app.layout = html.Div([
#     html.H1(children='Title of Dash App', style={'textAlign':'center'}),
#     dcc.Dropdown(df.country.unique(), 'Canada', id='dropdown-selection'),
#     dcc.Graph(id='graph-content')
# ])

# @callback(
#     Output('graph-content', 'figure'),
#     Input('dropdown-selection', 'value')
# )
# def update_graph(value):
#     dff = df[df.country==value]
#     return px.line(dff, x='year', y='pop')

# # Define callback function for updating the headlines table
# @app.callback(
#     Output('headlines-table', 'data'),
#     Input("topic-selector", "value"),
#     Input("domain-selector", "value"),
#     Input('date-range', 'start_date'),
#     Input('date-range', 'end_date')
# )
# def update_headlines_table(selected_topic, selected_domain, start_date, end_date):
#     # Filtering data...
tab_content_2 =  dcc.Markdown('''

    # Sobre o projeto

Quão positiva (ou negativa) foi a cobertura da imprensa portuguesa acerca do novo Acordo Ortográfico? E quanto à comunidades minorizadas como a LGBT? SentDiário é uma ferramenta que permite uma análise diacrônica detalhada das tendências midiáticas relativas a diferentes tópicos de interesse social. Nós apresentamos um modelo que permite classificar automaticamente o sentimento dos títulos de notícias, através de assuntos selecionados. Para esta versão *demo*, incluímos notícias arquivadas pelo **Arquivo.pt**, publicadas nos sites dos 10 principais portais de notícias de Portugal, de acordo com o [Instituto Reuters para o Estudo do Jornalismo](https://reutersinstitute.politics.ox.ac.uk/digital-news-report/2023/portugal): 

![corpus_arquivopt.jpg](corpus_arquivopt.jpg)

<iframe title="Weekly reach - online" aria-label="Split Bars" id="datawrapper-chart-5YFSg" src="https://datawrapper.dwcdn.net/5YFSg/2/" scrolling="no" frameborder="0" style="width: 0; min-width: 100% !important; border: none;" height="665" data-external="1"></iframe><script type="text/javascript">!function(){"use strict";window.addEventListener("message",(function(a){if(void 0!==a.data["datawrapper-height"]){var e=document.querySelectorAll("iframe");for(var t in a.data["datawrapper-height"])for(var r=0;r<e.length;r++)if(e[r].contentWindow===a.source){var i=a.data["datawrapper-height"][t]+"px";e[r].style.height=i}}}))}();</script>

## Por que analisar o sentimento de textos jornalísticos?
[Vizeu](https://revistaseletronicas.pucrs.br/ojs/index.php/revistafamecos/article/view/6321) (2009, p.77) argumenta que o jornalismo é um ‘lugar de referência’. Isto é, um lugar que estabelece parâmetros da realidade, aonde as pessoas vão em busca de ‘estabilidade’. Desta forma, é através do consumo de notícias que temos acesso a fatos diversos do cotidiano, e a forma como os interpretamos é mediada pelos meios de comunicação. O fato de um jornal publicar mais notícias positivas ou negativas sobre determinado assunto tem, portanto, o potencial de não apenas reproduzir, mas também, construir uma visão positiva ou negativa acerca daquele determinado tópico. Assim, analisar o sentimento das notícias ajuda a compreender como assuntos de relevância social são reportados pelos diferentes meios e qual o ‘tom’ adotado pelos jornais.  

## Mas notícias não deveriam ser sempre neutras?  
Quando falamos em neutralidade no jornalismo ([Ojala,2021](https://www.tandfonline.com/doi/full/10.1080/1461670X.2021.1942150)), nos referimos à busca por uma reportagem que não tome partido e apresente uma visão equilibrada dos fatos. Ao propor uma análise de sentimento, estamos levando em consideração que textos de notícia podem ser positivos, negativos ou neutros, na medida em que o discurso faz usos de palavras que carregam esses sentimentos. Veja abaixo exemplos de notícias de polaridade positiva, neutra e negativa:

- Positivo: [Festival pretende promover inclusão social da comunidade LGBTS](https://arquivo.pt/noFrame/replay/20120809234829id_/http://www.dn.pt/cartaz/interior.aspx?content_id=2710584) 
- Neutro: [Nasce uma igreja todos os meses em Portugal](https://arquivo.pt/noFrame/replay/20190811192132id_/https://www.dn.pt/pais/interior/nasce-uma-igreja-todos-os-meses-em-portugal--10887303.html)
- Negativo: [Cidadãos lançam iniciativa contra acordo ortográfico no Facebook](https://arquivo.pt/noFrame/replay/20100608075542id_/http://www.publico.pt/Sociedade/cidadaos-lancam-iniciativa-contra-acordo-ortografico-no-facebook_1424865)

## E por que analisar somente os títulos das notícias? E quanto ao resto do texto?
Títulos de notícias exercem uma série de funções ([Scacco & Muddiman, 2016](https://mediaengagement.org/research/clickbait-headlines/)), especialmente quando se trata do jornalismo online, que depende de clicks para mensurar sua audiência. Seja o título um resumo do conteúdo ou um clickbait, ele é o primeiro nível de acesso à informação (a primeira impressão) e, muitas vezes, também a única. 


>*Clickbait* é o nome dado à estratégia de se utilizar de títulos super atrativos ao leitor. Esses títulos, muitas vezes, fazem uso de palavras alarmantes, criam mistérios ou perguntas a serem respondidas (ou não) pelo restante do texto caso o leitor o acesse.


Devido ao uso de paywalls ou por conta de hábitos de consumo de notícias pelas redes sociais, os títulos acabam sendo a única dimensão da notícia que muitos leitores consomem. Por fim, a análise dos textos apresenta um desafio técnico que pode elevar a imprecisão dos algoritmos devido aos longos parágrafos, os quais tendem a apresentar fatos diversos com conteúdos contraditórios e fazendo uso de uma linguagem menos adjetivada (portanto mais objetiva), o que tende a acontecer de forma oposta em títulos. 

## Como usar a ferramenta?

- [List the specific goals and objectives of the project.]             

## Metodologia 

Utilizamos a API do Arquivo.pt para realizar as buscas, identificando, para cada tema, as palavras-chave, os diferentes portais de notícias e fixando o período de tempo relevante. Cada notícia extraída é classificada automaticamente, a partir do respectivo título, como: a) positiva, b) negativa ou c) neutra.

[FinBERT-PT-BR](https://huggingface.co/lucas-leme/FinBERT-PT-BR) foi o modelo utilizado por ter apresentado os melhores resultados quando comparado a diferentes modelos de análise de polaridade. Testamos os seguintes modelos: `pysentimiento`, `lxyuan`, `citizenlab`, `HeyLucasLeao`, `igoramf` e `satoken`. Também testamos a combinação de diferentes modelos, porém, FinBERT-PT-BR apresentou a melhor acurácia a partir de uma avaliação manual de 150 títulos realizada por dois anotadores falantes nativos de português.

Os resultados obtidos são, então, processados para serem apresentados de maneira otimizada. Primeiramente, para cada tópico, fornecemos a distribuição do número de publicações por mês e por portal de notícias. Em seguida, apresentamos a tendência global (ou seja, todos os portais combinados) das publicações e a evolução temporal. Além disso, para cada portal, é possível verificar as diferentes evoluções diacrônicas relativas às diferentes etiquetas utilizadas em nossa classificação.

Nós selecionamos quatro tópicos para demonstrar o interesse da nossa ferramenta (imigração, novo acordo ortográfico, LGBT e direitos reprodutivos/aborto), porém, o potencial dela vai além, e pode ser adaptada para abranger uma diversidade de assuntos. 

## Sobre a análise de sentimento: 

- **Como funciona?**
A *análise de sentimento* é uma forma de se utilizar de algorítimos de Processamento de Linguagem Natural (PLN) para quantificar a itensidade emocional de palavras, frases e textos. Ferramentas de classificação de sentimento se tornaram populares por seu uso comercial, no qual empresas de utilizam desses algorítimos para analisar a recepção de seus produtos através de comentários de consumidores na internet. Algorítimos treinados em diversas bases de dados podem funcionar de formas diversas. Em sua forma mais básica, o algorítimo pode conter um dicionário criado por pessoas, no qual um sentimento é atribuído a uma série de palavras. Desta forma, para determinar o sentimento de uma frase, basta calcular quantas palavras positivas, negativas ou neutras estão presentes nela. Formas mais sofisticadas surgiram ao longo do tempo, permitindo que os algorítimos não apenas usassem um dicionário, mas também compreendenssem a sintaxe da língua. Com o uso de aprendizado de máquinas, tem sido possível gerar algorítimos cada vez mais eficientes, que consigam lidar com desafios linguísticos e frases mais complexas.
  
- **Quais as principais limitações dessa metodologia?**

  - Notícias tem uma tendência negativa
    
    Como lembram Toff, Palmer e Nielsen no livro *[Evitando notícias: audiências relutantes em relação ao jornalismo](https://cup.columbia.edu/book/avoiding-the-news/9780231205191)* (2023, p.1), "Jornalistas não cobrem pousos de aviões". Existe por tanto uma tendência do jornalismo a jogar luz sobre fatos disruptivos do cotidiano, que tendem a ter uma natureza negativa. Há também indicativos de que o número de notícias negativas têm potencialmente aumentado ao longo dos últimos anos. De acordo com uma [pesquisa](https://journals.plos.org/plosone/article?id=10.1371/journal.pone.0276367) realizada por Rozado, Hudges e Halberstadt (2022), ouve um aumento no número de notícias negativas publicadas entre os anos 2000 e 2019 nos Estados Unidos. Os autores utilizaram análise de sentimento num corpus composto de 23 milhões de títulos de notícias publicadas por 47 meios de comunicação populares no país. Esse viés, entretanto, deve variar de acordo com o tópico ou evento analisado, sendo notícias positivas mais facilmente encontradas nas seções de 'viagens' ou 'esportes' de um jornal, por exemplo.  

  - Classificação negativa não significa necessariamente uma notícia ruim
    
    O método de classificação automatizada de sentimento considera o sentimento discursivamente expresso no texo a partir da escolha das palavras. Na notícia *[ONU critica resposta da administração Trump a manifestações racistas](https://arquivo.pt/noFrame/replay/20170831232240id_/http://observador.pt/2017/08/23/onu-critica-resposta-da-administracao-trump-a-manifestacoes-racistas/)*, por exemplo, por mais que a notícia seja boa (por se tratar de uma crítica a manifestações racistas), o fato de a notícia conter as palavras 'critica' e 'racistas' faz com que a polaridade seja calculada pelo algorítimo como 'negativa'. A classificação 'negativa', por tanto, se trata do uso de palavras negativas, e não, necessariamente, do fato de uma notícia ser boa ou ruim.  
  
  - Algumas frases são complexas demais
    
    Neste título *[Vasco Pulido Valente. Marcelo elogia "impiedosa independência crítica"](https://arquivo.pt/noFrame/replay/20200327212418id_/https://www.dn.pt/poder/amp/vasco-pulido-valente-marcelo-elogia-impiedosa-independencia-critica-11848581.html)* há um elogio feito com uso de palavras negativas ('impiedosa', 'crítica'). Enquanto um cronista, ser considerado como dono de uma 'impiedosa independência crítica' é positivo. Daí o motivo de algorítimos de análise de sentimento serem 'sensíveis ao contexto'. Frases que se utilizam de ironias e sarcasmo também dificultam a classificação de sentimento. Algumas vezes, sendo difícil não apenas para as máquinas (algorítimos) mas também para humanos interpretá-las. 

- **Os resultados são confiáveis?**

Como argumenta Rogers em [Doing Digital Methods](https://books.google.com/books/about/Doing_Digital_Methods.html?id=DLuODwAAQBAJ) (2019), reconhecer as limitações dos dados e suas formas de uso é inerente ao uso de métodos digitais. Embora o uso de classificações automatizadas de sentimento apresente desafios, esse método pode facilitar uma análise exploratória dos dados. Combinar esse método com outros, sejam eles quantitativos ou qualitativos (como a leitura manual dos dados),  é desejável para que seus resultados possam ser interpretados da melhor maneira e, em alguns casos, generalizados. 


> Para aprender mais sobre análise de sentimento: 
> - Zoë Wilkinson Saldaña, "Análise de sentimento para exploração de dados", traduzido por Caio Mello, Programming Historian em português 1 (2021), https://doi.org/10.46430/phpt0017.
> - Jennifer Isasi, "Análise de sentimentos em R com 'syuzhet'", traduzido por Diana Rebelo Rodriguez, Programming Historian em português 2 (2022), https://doi.org/10.46430/phpt0022.

## Autores

- [Caio Mello](https://caiocmello.github.io/): PhD Candidate, School of Advanced Study, University of London | E-mail: caiomellodh@gmail.com

- [Dr. Diego Alves](https://dfvalio.github.io/): Postdoctoral Researcher, Saarland University| E-mail: dfvalio@gmail.com

- [Dr. Gaurish Thakkar](https://thak123.github.io/): Researcher, University of Zagreb | E-mail: thak123@gmail.com
---
Obrigado por visitar nossa página. Para mais informações, sinta-se à vontade para entrar em contato com os autores do projeto. 

''')

app.layout = html.Div(
    [
        dbc.Card(
        [
            dbc.CardHeader(
                dbc.Tabs(
                    [
                        dbc.Tab(label="SentDiário", tab_id="tab-1"),
                        dbc.Tab(label="Sobre o projeto", tab_id="tab-2"),
                    ],
                    id="tabs",
                    active_tab="tab-1",
                )
            ),
            dbc.CardBody(html.Div(id="content", className="card-text")),
        ]
        )
    ]
)

@app.callback(Output("content", "children"), [Input("tabs", "active_tab")])
def switch_tab(at):
    if at == "tab-1":
        return tab_content_1
    elif at == "tab-2":
        return tab_content_2
    return html.P("This shouldn't ever be displayed...")
    
if __name__ == '__main__':
    app.run_server(debug=True)