Upload 27 files

.devcontainer/devcontainer.json

@@ -0,0 +1,33 @@
+{
+  "name": "Python 3",
+  // Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+  "image": "mcr.microsoft.com/devcontainers/python:1-3.11-bullseye",
+  "customizations": {
+    "codespaces": {
+      "openFiles": [
+        "README.md",
+        "app.py"
+      ]
+    },
+    "vscode": {
+      "settings": {},
+      "extensions": [
+        "ms-python.python",
+        "ms-python.vscode-pylance"
+      ]
+    }
+  },
+  "updateContentCommand": "[ -f packages.txt ] && sudo apt update && sudo apt upgrade -y && sudo xargs apt install -y <packages.txt; [ -f requirements.txt ] && pip3 install --user -r requirements.txt; pip3 install --user streamlit; echo '✅ Packages installed and Requirements met'",
+  "postAttachCommand": {
+    "server": "streamlit run app.py --server.enableCORS false --server.enableXsrfProtection false"
+  },
+  "portsAttributes": {
+    "8501": {
+      "label": "Application",
+      "onAutoForward": "openPreview"
+    }
+  },
+  "forwardPorts": [
+    8501
+  ]
+}

.dockerignore

@@ -0,0 +1,29 @@
+**/__pycache__
+**/.venv
+**/.classpath
+**/.dockerignore
+**/.env
+**/.git
+**/.gitignore
+**/.project
+**/.settings
+**/.toolstarget
+**/.vs
+**/.vscode
+**/.devcontainer
+**/*.*proj.user
+**/*.dbmdl
+**/*.jfm
+**/bin
+**/charts
+**/docker-compose*
+**/compose*
+**/Dockerfile*
+**/node_modules
+**/npm-debug.log
+**/obj
+**/secrets.dev.yaml
+**/values.dev.yaml
+**/notebooks
+LICENSE
+README.md

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/raw/500+_raw.xlsx filter=lfs diff=lfs merge=lfs -text
+resources/logo.png filter=lfs diff=lfs merge=lfs -text
+resources/mapa_calor_musicas.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/

Dockerfile

@@ -1,20 +1,24 @@
-FROM python:3.13.5-slim
-
-WORKDIR /app
-
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    git \
-    && rm -rf /var/lib/apt/lists/*
-
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
-
-EXPOSE 8501
-
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
-
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+# For more information, please refer to https://aka.ms/vscode-docker-python
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Copy and install system dependencies from packages.txt
+COPY packages.txt .
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends locales-all ffmpeg git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements and install
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy all project files
+COPY . .
+
+# Expose Streamlit default port
+EXPOSE 80
+
+# Run the Streamlit app
+CMD ["streamlit", "run", "app.py", "--server.port=80", "--server.address=0.0.0.0"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Denis Bruno
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,20 +1,236 @@
+# 500mais-kissfm
+Projeto de DataScience da lista das 500 mais da Kiss FM.
+
+A aplicação interativa com todas as análises aqui descritas está disponível em [https://500maiskissfm.streamlit.app/](https://500maiskissfm.streamlit.app/)
+
+# Tratamento de dados
+
+Antes da análise dos dados relativos à todos os anos das 500+ da Kiss FM foi necessário agrega-los. Os itens a seguir descrevem todo esse processo. 
+A maior parte dele foi automatizada, porém em alguns momentos uma intervenção manual foi necessária. Dessa forma, eventuais erros podem ter sido introduzidos na listagem, já que a conferência final foi feita por amostragem. Assim sendo, reporte qualquer inconsistência por meio das issues do repositório.
+
+## Ferramentas utitlizadas
+
+* Microsoft Excel
+* OpenRefine 3.7.7
+* Wikidata Reconciliation Service
+* Wikidata API
+
+Projeto do OpenRefine está disponível neste [arquivo](../main/data/500%2B_openrefine.tar.gz).
+
+## Coleta
+
+Os dados foram coletados a partir das <a href="#fontes">fontes</a> listadas, na ordem em que foram elencadas. Em alguns casos foi realizada uma referência cruzada das informações das fontes para tirar dúvidas sobre as informações das músicas, posições, álbuns, etc.
+Nesta etapa todo o trabalho foi realizado utilizando o Excel e o resultado final foi compilado no [arquivo raw](../main/data/raw/500%2B_raw.xlsx).
+Após isso foi gerada uma planilha com todas as 12.000 músicas (até o momento, compreendendo os anos 2000-2023) para início do processo de tratamento.
+
+## Tratamento e clusterização
+
+Para a limpeza e tratamento dos dados a planilha com todas as músicas foi importada no OpenRefine. A partir daí, algumas adequações e ajustes foram necessários para padronizar os dados, descritos a seguir.
+
+A padronização e unificação dos nomes foi realizado por meio dos métodos de [clustering do OpenRefine](https://openrefine.org/docs/technical-reference/clustering-in-depth). Foram utilizados diversos métodos até que fosse possível ter o mínimo possível de duplicatas. Ainda assim, alguma revisão manual foi realizada. 
+
+### Posição
+
+O tratamento dos dados de posição das <a href="#outras-considerações">músicas não identificadas</a> precisou de cruzamento das listagens das 500+ de algumas fontes. Em caso de conflitos entre 2 listas diferentes, optou-se por permanecer com os dados da lista mais recente.
+
+### Artista
+
+Os nomes dos artistas e bandas foram padronizados, agregando itens que estavam com diversos formatos (maiúsculo, minúsculo, com erros de grafia, etc.). Após isto foram analisados os casos específicos de colaboração, participação e junção de diferentes artistas em uma música.
+
+Para as colaborações optou-se por manter a junção por meio de conectivos, tais como "and", "&" ou "e". Isto foi orientado por uma rápida pesquisa na Wikipedia.
+
+As participações (conhecidas como "featuring") foram removidas do nome do artista e registradas em um novo campo "Observacao" no arquivo final (também utilizado para informações da música em si).
+
+### Música
+
+Os nomes das músicas também foram padronizados, agregando itens que estavam com diversos formatos (maiúsculo, minúsculo, com erros de grafia, etc.). Após isto foram analisados os casos específicos de "tipos" de músicas.
+
+Diversas observações foram realizadas para esses "tipos" de músicas, tais como "ao vivo", "acústica", ou alguma outra versão específica. Para músicas "ao vivo" e "acústica" em específico, essa observação norteou a escolha do álbum (descrito na próxima seção).
+
+Além disso, foi registrado também se a música foi repetida na lista daquele ano (ocorreram 32 vezes ao longo desses 24 anos). Nas fontes consultadas já havia a indicação de que algumas músicas estavam repetidas, o que leva a crer que não foi um erro de digitação de quem registrou a informação, mas sim uma falha na programação da própria Kiss. Neste caso, foi anotado no campo "observação" como "repetida", na música da posição mais baixa (ou seja, quando ela efetivamente foi repedita na reprodução).
+
+### Álbum/Single
+
+Optou-se pela escolha não somente de álbuns, mas também de singles como obra principal em que a música aparece. Assim sendo, a obra com data de lançamento mais antiga foi escolhida.
+
+No caso de músicas com observações, tais como "ao vivo" e "acústica" foi escolhido o primeiro álbum/single em que uma versão assim aparece.
+
+Como fonte de informação para checagem manual das datas de lançamento do álbum/single, o seguintes sites foram consultados, prevalecendo também a data mais antiga de lançamento encontrada:
+
+1. Wikipedia
+2. Rate Your Music
+3. Discogs
+
+Em alguns casos, apenas o ano (ou mês e ano) do lançamento foi identificado. Dessa forma, o registro foi marcado com o dia 01 de janeiro (ou do mês indicado) do respectivo ano. Ex:
+
+* Álbum lançado em ??/??/1956 -> Data de lançamento 01/01/1956
+* Álbum lançado em ??/12/1956 -> Data de lançamento 01/12/1956
+
+Todos os ��lbuns têm pelo menos o ano preenchido corretamente.
+
+Considerando que neste momento a análise dos dados neste projeto de DataScience será focada somente no ano, não haverá prejuízo. A busca por essa informação seguirá em andamento para refinar os dados.
+
+### País
+
+O país de origem dos artistas foi incluído com base em alguns critérios. O primeiro, a partir da reconciliação automática dos dados da Wikidata (explicado a seguir). O segundo, para o caso das bandas, prevaleceu o local de formação da mesma. No caso de artistas solo, o local de nascimento.
+
+Para músicas com colaborações e/ou participações, prevaleceu o país do artista principal.
+
+Por fim, optou-se por considerar todas as músicas pertencentes ao Reino Unido como Reino Unido em si mesmo, em vez de separar em Inglaterra, Escócia, Irlanda do Norte e País de Gales. Essa decisão foi tomada com base na análise de outros rankings de músicas que costumam considerar dessa forma (o dado original foi mantido na coluna "Country" do dataset).
+
+
+### Gênero Musical
+
+Enquadrar um artista em um único gênero musical é difícil pois a grande maioria não produz músicas em um único estilo, e esse estilo pode variar ao longo da carreira. Além disso, muitas variações de gêneros e sub-gêneros musicais podem gerar confusão. Entretanto, para esta análise uma classificação mínima foi necessária.
+
+Para isso, foi feito um cruazamento entre várias bases de dados de artistas de modo a tentar elencar o principal gênero musical:
+
+* Wikipédia
+* MusicBrainz
+* Last.fm
+* The Audio DB
+* Rate Your Music
+* Chosic
+* AllMusic
+
+Com base nos gêneros listados para um determinado artista nestas fontes, tentou-se encontrar o gênero musical que se repetiu mais entre todos, sendo este então atribuído ao artista.
+
+Após isso, os gêneros foram traduzidos para o português seguindo o que consta nas respectivas entradas na Wikipédia.
+
+### Duração
+
+A duração das músicas foi obtida a partir das músicas reconciliadas via OpenRefine e também por meio de web scrapping das respectivas páginas da Wikipédia (o notebook utilizado encontra-se no projeto).
+
+Para aquelas em que os dados não foram encontradas com os métodos acima, a duração foi localizada manualmente nas bibliotecas do Rate Your Music e Discogs.
+
+A duração indicada pode não ser precisa, uma vez que durante a programação das 500+ pode ser tido alguma variação de versão da música.
+
+
+## Reconciliação (via Wikidata)
+
+Boa parte do processo de tratamento de dados foi automatizado por meio da funcionalidade de [reconciliação](https://openrefine.org/docs/manual/reconciling) do OpenRefine e o respectivo serviços da Wikidata.
+
+Ao reconciliar os dados de artistas, músicas e álbuns com dados da Wikipedia foi possível validar as informações com confiabilidade. A reconciliação automática obteve os seguintes resultados:
+* Artistas: 98,33%
+* Músicas: 90%
+* Álbuns/Singles: 95%
+
+No caso dos Artistas, aqueles que possuem algum tipo de colaboração nas músicas não foi possível reconciliar. Para músicas e álbuns/singles, uma revisão manual foi realizada, elevando os índices de reconciliação para 94% e 98%, respectivamente.
+
+
+## Outras Considerações
+
+Após todo o trabalho, ainda restaram 11 músicas não identificadas nas fontes (2013: 1, 2007: 9, 2006: 1). Em duas delas há pelo menos a indicação dos artistas. Mesmo assim, pode haver erros no registro desses 2 casos. As músicas não identificadas são as seguintes:
+
+|Ano|Posição|Artista|Música|
+|:----|:----|:----|:----|
+|2013|311|?|?|
+|2007|49|?|?|
+|2007|54|?|?|
+|2007|97|?|?|
+|2007|262|?|?|
+|2007|265|?|?|
+|2007|266|?|?|
+|2007|267|?|?|
+|2007|269|?|?|
+|2007|304|Bad Company|?|
+|2006|471|Alice in Chains|?|
+
+Caso você consiga essa informação, por favor abra uma issue para que o arquivo possa ser complementado. 
+
+Em um projeto complementar tentarei estimar quais eram as possíveis músicas, com base na análise dos dados das músicas votadas em outros anos.
+
+
+**EDIT**: Graças à uma planilha cedida pelo [@humbertobiasin](https://x.com/humbertobiasin) pude preencher a lista dessas músicas não identificadas. Foram elas:
+
+* 2006: #471 - No Excuses (Alice in Chains)
+* 2007: #49 - Somebody to Love (Queen); #54 - We Are the Champions (Queen); #97 - Boys Don't Cry (The Cure); # 262 - Sister (The Nixons); #265 - Red Sector A (Rush); #266 - Runnin' With the Devil (Van Halen); #267 - The Long and Winding Road (The Beatles); 269 - Breakfast at Tiffany's (Deep Blue Something); #304 Only Time Will Tell (Asia) (A não identificada do Bad Company era Can't Get Enough e ficou na posição #303)
+* 2013: #311 - Sad but True (Metallica)
 ---
-title: Teste
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
-license: mit
----
 
-# Welcome to Streamlit!
+# Análise dos dados
+
+Após o correto tratamento dos dados, algumas análises foram realizadas. Além daquelas aqui descritas, todas as demais estarão na aplicação.
+
+## Ferramentas
+
+Foram utilizadas as seguintes ferramentas para analisar os dados:
+
+* Python 3.10.13
+* pandas 2.2.0
+* NumPy 1.24.4
+* Matplotlib 3.7.4
+* seaborn 0.12.2
+
+## Considerações
+
+Para a análise foram desconsideradas as músicas e artistas em branco, que representam as <a href="#outras-considerações">músicas não identificadas</a>. Também foram desconsideradas as músicas anotadas como repetidas. Músicas ao vivo e acústicas foram consideradas como diferentes.
+
+### O caso de Another Brick in the Wall
+
+A música "Another Brick in the Wall", do Pink Floyd, é um caso a parte a ser discutido.
+
+Em primeiro lugar, a música é dividida em 3 partes, que podem ser tocadas juntas ou em separado, sendo a parte 2 a mais conhecida. Nos dados obtidos durante a etapa de tratamento, em alguns anos havia a informação de qual parte foi tocado, porém em outros não. Neste caso, quando não foi mencionada a parte foi considerada que o que foi tocado é o conjunto das 3 partes.
+
+Em segundo lugar, ainda na execução das 3 partes há a possibilidade da execução da música "The Happiest Days of Our Lives", que antecede a parte 2. De novo, em alguns anos há a indicação de que essa música foi tocada junto com a parte 2, e em outros com todas as partes.
+
+Neste sentido, optou-se por considerar cada execução como uma música distinta. Isto, por sua vez, gera uma distorção nas análises, uma vez que faz com que "Another Brick in the Wall" não apareça como uma música presente em todos os anos, mas sim alguma de suas partes.
+
+Uma forma de corrigir essa distorção é tratar todas elas como se fosse uma só, por meio do seguinte código:
+
+```
+df.loc[df['Musica'].str.contains('Another Brick', na=False), 'Musica'] = 'Another Brick in the Wall'
+```
+
+### A edição de 23/24
+
+Na edição de 23/24 a Kiss integrou na listagem das 500+ pela primeira vez músicas em português, o que gerou um grande outlier na amostragem de músicas e algumas distorções (por exemplo). Para uma análise mais precisa o ideal seria ter desconsiderado retirar este ano, porém não foi realizado.
+
+## Análises
+
+O primeiro resultado interessante da análise é ver a evolução da quantidade de músicas distintas que foram sendo incorporados a cada novo ano, chegando a um total de 2163 músicas. Uma crescente maior nos primeiros anos (por razões óbvias) e se estabilizando ao longo do tempo, voltando a crescer novamente em 23/24, pelas razões já <a href="#o-ano-de-2324">explicadas anteriormente</a>.
+
+![Evolução de músicas distintas ao longo dos anos](./resources/evolucao_musicas.png "Evolução de músicas distintas ao longo dos anos")
+
+Outra análise é ver a quantidade de músicas distintas por década de seu lançamento. Como esperado, há um domínio de músicas das décadas de 70 e 80 (com a década de 70 ligeiramente à frente), uma vez que foram os anos de ouro do classic rock.
+
+![Contagem de músicas por décadas de lançamento](./resources/musicas_decadas.png "Contagem de músicas por décadas de lançamento")
+
+De todas as 2163 músicas até agora já tocadas na programação das 500+ nesses 24 anos, interessante notar que apenas 15 delas estiveram presentes em todas as edições (sem contar <a href="#o-caso-de-another-brick-in-the-wall">"Another Brick in the Wall"</a>), o que representa 0,69%.
+
+Entre essas, as maiores vencedoras das 500+, "Stairway to Heaven" e "Bohemian Rhapsody" acumulam 16 vitórias, sendo 10 para a primeira e 6 para a segunda.
+
+![Mapa de calor de músicas que apareceram em todas as edições](./resources/mapa_calor_musicas.png "Mapa de calor de músicas que apareceram em todas as edições")
+
+Nenhuma música conquistou um "tricampeonato". "Stairway to Heaven" tem 4 bicampeonatos.
+
+## As maiores de todos os tempos
+
+Por fim, a análise mais interessante, e que foi o principal motivador desse projeto, foi descobrir quais são as maiores de todos os tempos das 500+!
+
+Para isso foi empregada uma [Média Bayesiana](https://en.wikipedia.org/wiki/Bayesian_average) de todas as posições de uma determinada música. A média bayesiana ajuda a eliminar distorções de músicas que aparecem pouquíssimas vezes (1 ou 2) em posições melhores, com pesos atribuídos em função da quantidade de aparições. Esse é um cálculo muito utilizado em tratamento de rankings de produtos e itens a partir de avaliações de usuários, como por exemplo no IMDb e Amazon. Este [artigo](https://arpitbhayani.me/blogs/bayesian-average/) explica bem o conceito.
+
+São elas:
+
+|Posição|Artista|Música|
+|:----|:----|:----|
+|1|Queen|Bohemian Rhapsody|
+|2|Led Zeppelin|Stairway to Heaven|
+|3|Deep Purple|Smoke on the Water|
+|4|Led Zeppelin|Kashmir|
+|5|Eagles|Hotel California|
+|6|The Beatles|Help!|
+|7|AC/DC|Back in Black|
+|8|Iron Maiden|Fear of the Dark|
+|9|The Rolling Stones|(I Can't Get No) Satisfaction|
+|10|Dire Straits|Sultans of Swing|
+
+Em função de ter ficado em 27ª em 23/24, "Stairway to Heaven" acaba ficando em segundo lugar, mesmo tendo vencido em 10 anos de votação. Uma posição a menos (26ª) e já seria um empate. Novamente, a edição 23/24 acabou gerando uma distorção.
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## Fontes
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+1. Planilha compilada pelo [@fabriciorby](https://x.com/fabriciorby) - https://docs.google.com/spreadsheets/d/1OHdR-RKBsELOR5nZ-L5pa8OohbvdNT29z7T-6SfWD70/
+2. Planilha compilada gentilmente cedida pelo [@humbertobiasin](https://x.com/humbertobiasin)
+3. Blog "LISTA das 500 MAIS da KISS FM de 2000 a 2023" - https://leitespc.blogspot.com/
+4. Blog "Álbuns de Cabeceira" - https://albunsdecabeceira.blogspot.com/
+5. Site Whiplash - https://whiplash.net/materias/melhores/195761.html, https://whiplash.net/materias/melhores/170703.html

app.py

@@ -0,0 +1,468 @@
+import json
+import base64
+import core_functions as core
+import charts as ch
+import components as components
+from info import InfoEdicao, InfoMusica, InfoArtista, InfoCuriosidade
+import locale
+import streamlit as st
+from streamlit_timeline import timeline
+
+#Configuração
+locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')
+logo_file = './resources/logo.png'
+icon_file = './resources/favicon.ico'
+versao = '1.4.0'
+
+def configurar_css():
+    st.markdown(
+    """
+<style>
+    [data-testid='stMetricDeltaIcon-Up'] {
+        display: none;
+    }
+</style>
+""",
+    unsafe_allow_html=True,
+)
+
+def plotar_grafico(fig):
+    st.plotly_chart(fig, use_container_width=True)
+
+def plotar_mapa_calor(fig):
+    config = {'scrollZoom': False,
+      'modeBarButtonsToRemove': [
+          'zoom', 'pan', 'select', 'zoomIn', 'zoomOut', 'autoScale', 'resetScale']}
+
+    st.plotly_chart(fig, use_container_width=True, config = config)
+
+def plotar_timeline(edicao):
+    items = json.loads(edicao.get_musicas())
+
+    options = {
+        "start_at_end": False,
+        "timenav_height": 50,
+        "is_embed": True,
+        "scale_factor": 11,
+        "duration": 300,
+        "language": "pt-br"
+    }
+
+    timeline(items, height=400, additional_options=options)
+
+@st.cache_resource(show_spinner='Gerando gráfico de corrida...')
+def plotar_grafico_race(df_data, atributo, titulo):
+    html_data = ch.gerar_grafico_race(df_data, atributo, titulo)
+
+    start = html_data.find('base64,') + len('base64,')
+    end = html_data.find('">')
+
+    video = base64.b64decode(html_data[start:end])
+    st.video(video)
+
+@st.cache_data
+def load_data(agregar_pinkfloyd):
+    return core.load_data(agregar_pinkfloyd)
+
+@st.cache_data
+def load_predicoes():
+    return core.load_predicoes()
+
+@st.cache_data
+def get_dicionario_musicas(df_data):
+    return core.get_dicionario_musicas(df_data)
+
+@st.cache_data
+def get_dicionario_artistas(df_data):
+    return core.get_dicionario_artistas(df_data)
+
+@st.cache_data
+def show_data(df_data):
+    st.dataframe(data=df_data.reset_index(drop=True), hide_index=True)
+
+#App
+st.set_page_config(layout="wide", 
+                    page_title='As 500+ da Kiss',
+                    page_icon=icon_file, 
+                    menu_items={
+                        'Get Help': 'https://github.com/denisvirissimo/500mais-kissfm',
+                        'Report a bug': "https://github.com/denisvirissimo/500mais-kissfm/issues",
+                        'About': '''Desenvolvido por [Denis Bruno Viríssimo](https://www.linkedin.com/in/denisbruno/)   
+                        Versão {}'''.format(versao)
+                    })
+
+configurar_css()
+
+if 'opt_pink_floyd' not in st.session_state:
+    st.session_state.opt_pink_floyd = False
+
+df_listagem = load_data(st.session_state.opt_pink_floyd)
+df_predicoes = load_predicoes()
+
+list_analises_edicao = {"Músicas por Artista":'Musica_Artista', "Álbuns por Artista":'Album_Artista', "Músicas por Gênero":'Musica_Genero', "Gêneros por País":'Genero_Pais', "Duração":'Duracao'}
+list_variaveis_topn = {"Artista": 'Artista', "Música": 'Musica', "Álbum/Single": 'Album', "Gênero": 'Genero', "Artistas com músicas em posições similares": 'Artista_Posicao'}
+medidas = ["Média", "Mediana", "Máximo"]
+
+
+#Sidebar
+st.sidebar.subheader('Filtros')
+st.sidebar.text('')
+
+#Filtro Edições
+edicoes = core.listar_edicoes(df_listagem)
+edicao_inicial, edicao_final = st.sidebar.select_slider('Filtrar por edições', edicoes, value = [core.get_primeira_edicao(df_listagem).values[0], core.get_ultima_edicao(df_listagem).values[0]])
+df_listagem_filtrada = core.filtrar_edicao(df_listagem, edicao_inicial, edicao_final)
+
+#Filtro Posições
+posicoes = core.listar_posicoes(df_listagem)
+posicao_inicial, posicao_final = st.sidebar.select_slider('Filtrar por posições', posicoes, value=[min(posicoes), max(posicoes)])
+df_listagem_filtrada = core.filtrar_posicoes(df_listagem_filtrada, posicao_inicial, posicao_final)
+
+#Filtro Ano Lançamento
+anos = core.listar_anos_lancamento(df_listagem)
+ano_inicial, ano_final = st.sidebar.select_slider('Filtrar por anos de lançamento das músicas', anos, value=[min(anos), max(anos)])
+df_listagem_filtrada = core.filtrar_anos(df_listagem_filtrada, ano_inicial, ano_final)
+
+st.sidebar.caption('Estes filtros se aplicam somente às abas Visão Geral e Análises.')
+
+st.sidebar.subheader('Opções')
+
+st.sidebar.toggle('Agregar múltiplas versões de Another Brick in the Wall', key='opt_pink_floyd', help='[Clique aqui](https://github.com/denisvirissimo/500mais-kissfm#o-caso-de-another-brick-in-the-wall) para entender.')
+
+col1, col2, col3 = st.columns((.2, 7.1, .2))
+
+with col2:
+    row_titulo_col1, row_titulo_col2 = st.columns((.25, 3.3), gap="small")
+    with row_titulo_col1:
+        st.image(logo_file, width=75)
+    with row_titulo_col2:
+        st.title('As 500+ da Kiss FM')
+
+    st.markdown("Esse é um projeto de Ciência de Dados com o objetivo de analisar a listagem das 500+ da rádio Kiss FM. A ideia surgiu a partir da curiosidade de saber qual seria a música número 1 de todas as votações até então, e acabou levando ao desenvolvimento de várias outras análises interessantes.")
+    st.markdown("Todo o detalhamento do projeto, inclusive o tratamento de dados e algumas curiosidades, está disponível neste [repositório do GitHub](https://github.com/denisvirissimo/500mais-kissfm)")
+
+    st.markdown("")
+    with st.status("Carregando...") as status:
+        show_data(df_listagem)
+        status.update(label="Clique aqui para ver a listagem completa", state="complete")
+
+    st.text('')
+    st.subheader("Exibindo os seguintes dados a partir dos filtros:")
+
+    row_numeros_col1, row_numeros_col2, row_numeros_col3, row_numeros_col4, row_numeros_col5, row_numeros_col6, row_numeros_col7 = st.columns((1.6, 1.6, 1.0, 1.5, 1.6, 1.4, 1.1), gap="small")
+    with row_numeros_col1:
+        total_musicas = df_listagem_filtrada.Id.nunique()
+        str_total_musicas = "🎶 {} músicas no total".format(locale.format_string("%d", total_musicas, grouping = True))
+        st.markdown(str_total_musicas)
+    with row_numeros_col2:
+        total_musicas_distintas = core.get_total_musicas_distintas(df_listagem_filtrada)
+        str_total_musicas_distintas = "🎵 {} músicas diferentes".format(locale.format_string("%d", total_musicas_distintas, grouping = True))
+        st.markdown(str_total_musicas_distintas)
+    with row_numeros_col3:
+        total_artistas = core.get_total_artistas_distintos(df_listagem_filtrada)
+        str_total_artistas = "👨🏽‍🎤 {} artista(s)".format(locale.format_string("%d", total_artistas, grouping = True))
+        st.markdown(str_total_artistas)
+    with row_numeros_col4:
+        total_albuns = core.get_total_albuns_distintos(df_listagem_filtrada)
+        str_total_albuns = "💿 {} álbum(s)/single(s)".format(locale.format_string("%d", total_albuns, grouping = True))
+        st.markdown(str_total_albuns)
+    with row_numeros_col5:
+        total_paises = core.get_total_paises_distintos(df_listagem_filtrada)
+        str_total_paises = "🌎 {} países representados".format(locale.format_string("%d", total_paises, grouping = True))
+        st.markdown(str_total_paises)
+    with row_numeros_col6:
+        total_generos = core.get_total_generos_distintos(df_listagem_filtrada)
+        str_total_generos = "🤘 {} gêneros musicais".format(locale.format_string("%d", total_generos, grouping = True))
+        st.markdown(str_total_generos)
+    with row_numeros_col7:
+        total_horas = core.get_total_horas(df_listagem_filtrada)
+        str_total_horas = "🕛 {}+ horas".format(locale.format_string("%d", total_horas, grouping = True))
+        st.markdown(str_total_horas)
+
+    st.divider()
+
+    tab_geral, tab_edicao, tab_edicoes, tab_analises, tab_curiosidades, tab_predicoes = st.tabs(["Visão Geral", "Por Edição", "Todas as Edições", "Análises", "Curiosidades", "Predições"])
+
+    with tab_geral:
+        st.subheader('Evolução de músicas distintas ao longo dos anos')
+        plotar_grafico(ch.get_grafico_barra(core.get_acumulado_musicas_distintas(df_listagem_filtrada), "Anos", "Acumulado", "Edições", "Acumulado de Músicas distintas"))
+
+        st.divider()
+
+        st.subheader('Evolução de gêneros musicais distintos ao longo dos anos')
+        plotar_grafico(ch.get_grafico_barra(core.get_acumulado_generos_distintos(df_listagem_filtrada), "Anos", "Acumulado", "Edições", "Acumulado de Gêneros Musicais distintos"))
+
+        st.divider()
+
+        st.subheader('Artistas, Músicas, Álbuns e Gêneros no Topo')
+
+        row_topn_col1, row_topn_col2 = st.columns((2, 5), gap="large")
+        with row_topn_col1:
+            top_n = st.slider('Qual Top N você deseja visualizar?', 1, 50, 3)
+            variavel_topn_selecionada = st.selectbox ("Escolha a variável para visualizar no Top", list(list_variaveis_topn.keys()), key = 'variavel_topn')
+            if (list_variaveis_topn[variavel_topn_selecionada] == 'Artista_Posicao'):
+                st.caption('Considera-se música em posição similar aquela com uma variação de até 5 posições (para mais ou para menos)')
+        with row_topn_col2:
+            match list_variaveis_topn[variavel_topn_selecionada]:
+                case 'Artista':
+                    st.dataframe(data=core.get_artistas_top_n(df_listagem_filtrada, top_n), hide_index=True, use_container_width=True, height=400, column_config={"Artista":"Artista", "Total_Aparicoes": "Número Total de Aparições"})
+                case 'Musica':
+                    st.dataframe(data=core.get_musicas_top_n(df_listagem_filtrada, top_n), hide_index=True, use_container_width=True, height=400, column_config={"Musica":"Música", "Total_Aparicoes": "Número Total de Aparições"})
+                case 'Album':
+                    st.dataframe(data=core.get_albuns_top_n(df_listagem_filtrada, top_n), hide_index=True, use_container_width=True, height=400, column_config={"Album_Single":"Álbum/Single", "Total_Aparicoes": "Número Total de Aparições"})
+                case 'Genero':
+                    st.dataframe(data=core.get_generos_top_n(df_listagem_filtrada, top_n), hide_index=True, use_container_width=True, height=400, column_config={"Genero":"Gênero", "Total_Aparicoes": "Número Total de Aparições"})
+                case 'Artista_Posicao':
+                    st.dataframe(data=core.get_artistas_posicoes_semelhantes_top_n(df_listagem_filtrada, top_n), hide_index=True, use_container_width=True, height=400, column_config={"Artista": "Artista", "Posicao_Semelhante": st.column_config.NumberColumn("Porcentagem de vezes em posições similares", format="percent")})
+                case default:
+                    st.write('Escolha uma opção')
+
+        st.divider()
+
+        st.subheader('Músicas distintas por Ano de Lançamento')
+        plotar_grafico(ch.get_grafico_barra(core.get_musicas_ano_lancamento(df_listagem_filtrada), "Data_Lancamento_Album", "Total_Musicas", "Anos", "Quantidade de Músicas distintas", True))
+
+        st.divider()
+
+        st.subheader('Músicas distintas por Década de Lançamento')
+        plotar_grafico(ch.get_grafico_barra(core.get_musicas_decada_lancamento(df_listagem_filtrada), "Decada_Lancamento_Album", "Total_Musicas", "Décadas", "Quantidade de Músicas distintas"))
+
+        st.divider()
+
+        st.subheader('Músicas distintas por País do Artista')
+        plotar_grafico(ch.get_grafico_barra_stacked(core.get_musicas_por_pais(df_listagem_filtrada), "Edicao", "Total_Musicas", "Pais", "Edições", "Músicas por País", "Países"))
+
+        st.divider()
+
+        st.subheader('Músicas distintas por Gênero Musical do Artista')
+        plotar_grafico(ch.get_grafico_barra_stacked(core.get_musicas_por_genero(df_listagem_filtrada), "Edicao", "Total_Musicas", "Genero", "Edições", "Músicas por Gênero Musical", "Gêneros Musicais"))
+
+        st.divider()
+
+        row_posicaogenero, row_paises = st.columns((3.5, 3.5), gap="large")
+        with row_posicaogenero:
+            st.subheader('Melhor posição de cada gênero')
+            st.dataframe(data=core.get_melhor_posicao_genero(df_listagem_filtrada), hide_index=True, use_container_width=True, height=400, column_config={"Genero":"Gênero", "Posicao": "Melhor Posição", "Edicao": "Edição"})
+
+        with row_paises:
+            st.subheader('Mapa de Países')
+            plotar_grafico(ch.get_mapa(core.get_musicas_por_pais(df_listagem_filtrada, True), "Country", "Total_Musicas", "Pais", "Quantidade de Músicas"))
+
+    with tab_edicao:
+
+        st.markdown('Escolha uma edição e veja algumas informações relavantes:')
+
+        row_edicoes_col1, row_edicoes_col2= st.columns((1.5, 6.2), gap="small")
+        with row_edicoes_col1:
+            anos = core.listar_anos_edicoes(df_listagem)
+            list_edicoes = dict(zip(edicoes, anos))
+            edicao_selecionada = st.selectbox ("Edição", list_edicoes.keys(), key = 'edicao_selecionada')
+
+        ano_edicao = list_edicoes[edicao_selecionada]
+        info_edicao = InfoEdicao(df_listagem, ano_edicao)
+        st.divider()
+
+        st.subheader("Linha do tempo das músicas na edição")
+        plotar_timeline(info_edicao)
+
+        st.caption('Use os as setas ao lado para avançar/retornar na linha do tempo. Clique e arraste na linha para avançar um período maior.')
+
+        st.divider()
+        row_dadosedicao_col1, row_dadosedicao_col2, row_dadosedicao_col3 = st.columns((1.2, 2.6, 2.6), gap="large")
+
+        with row_dadosedicao_col1:
+            st.subheader('Dados Gerais')
+
+
+            st.markdown('Neste ano a 1ª posição ficou com **{}** e a posição de número 500 com **{}**.'.format(info_edicao.get_musica_posicao(1), info_edicao.get_musica_posicao(500)))
+
+            st.markdown('O Artista em que mais apareceu na listagem foi **{}**.'.format(info_edicao.get_top_artista()))
+            st.markdown('Já o Álbum/Single com mais músicas na lista foi **{}**.'.format(info_edicao.get_top_album()))
+
+            st.markdown('O Gênero Musical mais tocado foi **{}**.'.format(info_edicao.get_top_genero()))
+
+            st.markdown('A Música de menor duração foi **{}** e a música de maior duração foi **{}**'.format(info_edicao.get_musica_menor_duracao(), info_edicao.get_musica_maior_duracao()))
+
+            st.markdown('E tivemos música repetida? **{}**!'.format(info_edicao.get_repetidas()))
+
+        with row_dadosedicao_col2:
+            st.subheader('Países dos Artistas na Edição')
+            plotar_grafico(ch.get_grafico_pizza(info_edicao.get_lista_paises(), 'Quantidade', 'Pais', 'Músicas', 'País'))
+
+        with row_dadosedicao_col3:
+            st.subheader('Gêneros Musicais na Edição')
+            plotar_grafico(ch.get_grafico_pizza(info_edicao.get_lista_generos(), 'Quantidade', 'Genero', 'Músicas', 'Gênero Musical'))
+
+        st.divider()
+        if (ano_edicao != anos[0]):
+            row_edicaosubidas, row_edicaoquedas = st.columns((3.5, 3.5), gap="large")
+
+            with row_edicaosubidas:
+                st.subheader('Maiores subidas no ranking')
+                plotar_grafico(ch.get_grafico_slope(core.get_variacao_entre_anos(df_listagem, ano_edicao -1, ano_edicao, 5, False), 'Ano', ano_edicao - 1, ano_edicao, 'Posicao_Anterior', 'Posicao_Atual', 'Musica', 'Artista', 'Variaçãos no Ranking'))
+
+            with row_edicaoquedas:
+                st.subheader('Maiores quedas no ranking')
+                plotar_grafico(ch.get_grafico_slope(core.get_variacao_entre_anos(df_listagem, ano_edicao -1, ano_edicao, 5, True), 'Ano', ano_edicao - 1, ano_edicao, 'Posicao_Anterior', 'Posicao_Atual', 'Musica', 'Artista', 'Variaçãos no Ranking'))
+
+            st.divider()
+
+        st.subheader('Mapa de Gêneros Músicais')
+        plotar_grafico(ch.get_analise_edicao_treemap(info_edicao.get_lista_generos(), 'Genero', 'Quantidade', 'Gênero', 'Quantidade de Músicas'))
+
+    with tab_analises:
+        st.subheader('Análises por edição')
+        st.markdown('A análise de alguns aspectos por edição pode mostrar a diversidade de músicas, álbuns e gêneros musicais a cada edição.')
+        row_anelisemusica_col1, row_anelisemusica_col2 = st.columns((1.5, 6.2), gap="small")
+        with row_anelisemusica_col1:
+            analisemusica_edicao_selecionada = st.selectbox("Escolha o aspecto", list(list_analises_edicao.keys()), key = 'analise_edicao')
+            analisemusica_medida_selecionada = st.selectbox("Escolha a medida", medidas, key = 'medida_edicao')
+        with row_anelisemusica_col2:
+            plotar_grafico(ch.get_grafico_barra(core.get_analise_edicao(df_listagem_filtrada, analisemusica_medida_selecionada, list_analises_edicao[analisemusica_edicao_selecionada]),
+                                "Edicao",
+                                analisemusica_medida_selecionada,
+                                "Edições",
+                                analisemusica_medida_selecionada + ' de ' + analisemusica_edicao_selecionada))
+
+        st.divider()
+        st.subheader('One-Hit Wonders vs Recorrentes')
+        st.markdown('A análise de artistas que tiveram somente uma única música diferente em edições até hoje vs artistas que tiveram pelo menos duas músicas diferentes ajuda a compreender a preferência dos ouvintes')
+        plotar_grafico(ch.get_grafico_linha(core.get_onehit_por_edicao(df_listagem_filtrada), 'Edicao', 'Recorrentes', 'Edições', 'Artistas', 'Recorrentes', 'One_Hit_Wonders', 'One-Hit Wonders'))
+
+        st.divider()
+        st.subheader('Idade das músicas')
+        st.markdown('A análise de idade das músicas demonstra se há uma tradição de votação em músicas mais antigas (especialmente da década de 70) ou se têm sido incorporadas músicas mais recentes na listagem.')
+        st.markdown('A idade é recalculada a cada edição.')
+
+        plotar_grafico(ch.get_grafico_linha(core.get_idade_por_edicao(df_listagem_filtrada), 'Edicao', 'Media_Idade_Lancamento', 'Edições', 'Idade', 'Média de Idade', 'Mediana_Idade_Lancamento', 'Mediana de Idade'))
+
+    with tab_curiosidades:
+
+        info_curiosidades = InfoCuriosidade(core.filtrar_inconsistencias(df_listagem))
+
+        curiosidade = info_curiosidades.get_primeiro_artista_br()
+        st.markdown('* A primeira aparição de um artista brasileiro foi em {} com {}, ficando na {}ª posição.'.format(curiosidade[1], curiosidade[0], curiosidade[2]))
+
+        curiosidade = info_curiosidades.get_edicao_menos_artistas()
+        st.markdown('* A edição com menos artistas foi a {}, contando com "apenas" {} artistas.'.format(curiosidade[0], curiosidade[1]))
+
+        curiosidade = info_curiosidades.get_edicao_mais_artistas()
+        st.markdown('* Já a edição com mais artistas foi a {}, com {} artistas.'.format(curiosidade[0], curiosidade[1]))
+
+        curiosidade = info_curiosidades.get_artista_mais_musicas_edicao()
+        st.markdown('* O recorde de mais músicas em uma única edição é de {} com impressionantes {} músicas na edição {}.'.format(curiosidade[0], curiosidade[1], curiosidade[2]))
+
+        curiosidade = info_curiosidades.get_one_hit_wonder()
+        st.markdown('* {} ({}%) artistas aparceram nas edições com uma única música (os chamados "one-hit wonders")'.format(curiosidade[0], curiosidade[1]))
+        
+        curiosidade = info_curiosidades.get_album_mais_musicas_edicao()
+        st.markdown('* O álbum/single com mais músicas em uma única edição é {} com {} músicas na edição {}.'.format(curiosidade[0], curiosidade[1], curiosidade[2]))
+
+        curiosidade = info_curiosidades.get_album_mais_musicas()
+        st.markdown('* O álbum/single com mais músicas em todas as edições é {} de {}, com {} músicas. Isto representa {} % de todas as músicas.'.format(curiosidade[1], curiosidade[0], curiosidade[2], curiosidade[3]))
+
+        curiosidade = info_curiosidades.get_duracao()
+        st.markdown('* A música com menor duração teve {} e a música com maior duração {}.'.format(curiosidade[0], curiosidade[1]))
+
+        curiosidade = info_curiosidades.get_artista_maior_percentual()
+        st.markdown('* {} é o artista com maior número de músicas: {}, o que representa {} % do total de músicas.'.format(curiosidade[0], curiosidade[1], curiosidade[2]))
+
+    with tab_predicoes:
+        row_predicoes_col1, row_predicoes_col2 = st.columns((3, 3.5), gap="small")
+
+        with row_predicoes_col1:
+            st.subheader('Predições das 500+ para {}'.format(max(anos)+1))
+            st.dataframe(core.get_predicoes(df_predicoes), hide_index=True, column_config={"posicao_ranking": st.column_config.Column("Posição", width=1), "Artista": "Artista", "Musica": "Música"})
+
+        with row_predicoes_col2:
+            st.subheader('Probabilidades da música aparecer em {}'.format(max(anos)+1))
+            st.dataframe(core.get_probabilidades(df_predicoes), hide_index=True, column_config={"Artista": "Artista", "Musica": "Música", "prob_aparecer": st.column_config.NumberColumn("Probabildiade de Aparecer", format="%.2f %%")})
+
+    with tab_edicoes:
+
+        rwo_ranking, row_videos= st.columns((3.8, 3.8), gap="small")
+
+        with rwo_ranking:
+            st.subheader('Top 10 de todas as edições')
+            components.top10(core.get_top_n_todas_edicoes(df_listagem, 10))
+            st.caption('Para entender como essa lista foi criada, consulte [a explicação](https://github.com/denisvirissimo/500mais-kissfm#as-maiores-de-todos-os-tempos).')
+        st.divider()
+
+        st.subheader('Mapa de calor de músicas presentes em todas as edições')
+        plotar_mapa_calor(ch.get_mapa_calor(core.get_musicas_todos_anos(df_listagem), "Edição", "Música", "Posição", "Edições", "Músicas"))
+
+        st.divider()
+
+        row_anelisemusica_col1, row_anelisemusica_col2= st.columns((3.5, 4.1), gap="small")
+        with row_anelisemusica_col1:
+            st.subheader('Informações da música')
+
+            lista_select_musicas = get_dicionario_musicas(df_listagem)
+            musica_selecionada = st.selectbox(
+              'Escolha a música',
+              label_visibility='hidden',
+              options=lista_select_musicas.keys(),
+              index=None,
+              placeholder='Digite ou escolha a música',
+              format_func=lambda l: lista_select_musicas[l])
+
+            st.text('')
+
+        if (musica_selecionada != None):
+            row_infomusica_col1, row_infomusica_col2, row_infomusica_col3, row_infomusica_col4 = st.columns(4)
+            info_musica = InfoMusica(core.filtrar_inconsistencias(df_listagem), musica_selecionada)
+            row_infomusica_col1.metric(label="📈 Melhor Posição", value=str(info_musica.get_melhor_posicao()) + 'ª', delta=info_musica.get_edicao_melhor_posicao(), delta_color='off')
+            row_infomusica_col2.metric(label="📉 Pior Posição", value=str(info_musica.get_pior_posicao()) + "ª", delta=info_musica.get_edicao_pior_posicao(), delta_color='off')
+            row_infomusica_col3.metric(label="📊 Posição Média", value=str(info_musica.get_posicao_media()) + "ª")
+            row_infomusica_col4.metric(label="🗓️ Década", value=info_musica.get_decada())
+            st.text('')
+            row_infomusica_col5, row_infomusica_col6, row_infomusica_col7, row_infomusica_col8= st.columns(4)
+            row_infomusica_col5.metric(label="#️⃣ Número Aparições", value=info_musica.get_numero_aparicoes())
+            row_infomusica_col6.metric(label='🔥 Aparições Consecutivas', value=info_musica.get_numero_aparicoes_consecutivas())
+            row_infomusica_col7.metric(label='🏅 Número Pódios', value=info_musica.get_numero_podios())
+            row_infomusica_col8.metric(label='🏅 Pódios Consecutivos', value=info_musica.get_numero_podios_consecutivos())
+
+            st.subheader('Histórico')
+            plotar_grafico(ch.get_grafico_linha(info_musica.get_posicoes(),'Ano', 'Posicao', 'Ano', 'Posição no ranking', '', reversed=True))
+
+        st.divider()
+
+        row_aneliseartista_col1, row_aneliseartista_col2= st.columns((3.5, 4.1), gap="small")
+        with row_aneliseartista_col1:
+            st.subheader('Informações do artista')
+
+            lista_select_artistas = get_dicionario_artistas(df_listagem)
+            artista_selecionado = st.selectbox(
+                'Escolha o artista',
+                label_visibility='hidden',
+                options=lista_select_artistas.keys(),
+                index=None,
+                placeholder='Digite ou escolha o artista',
+                format_func=lambda l: lista_select_artistas[l])
+
+            st.text('')
+
+        if (artista_selecionado != None):
+            row_infoartista_col1, row_infoartista_col2, row_infoartista_col3, row_infoartista_col4 = st.columns(4)
+            info_artista = InfoArtista(core.filtrar_inconsistencias(df_listagem), artista_selecionado)
+            row_infoartista_col1.metric(label="📈 Melhor Posição", value=str(info_artista.get_melhor_posicao()) + 'ª', delta=info_artista.get_edicao_melhor_posicao(), delta_color='off')
+            row_infoartista_col2.metric(label="📉 Pior Posição", value=str(info_artista.get_pior_posicao()) + "ª", delta=info_artista.get_edicao_pior_posicao(), delta_color='off')
+            row_infoartista_col3.metric(label="🎶 Total Músicas", value=info_artista.get_total_musicas())
+            row_infoartista_col4.metric(label="️#️⃣ Número Edições", value=info_artista.get_total_edicoes())
+            st.text('')
+            row_infoartista_col5, row_infoartista_col6, row_infoartista_col7, row_infoartista_col8= st.columns(4)
+            row_infoartista_col5.metric(label="️🎵Média Músicas", value=locale.format_string("%.2f", info_artista.get_media_musicas_por_edicao(), grouping = True), delta="por edição", delta_color='off')
+            row_infoartista_col6.metric(label='🔥 Aparições Consecutivas', value=info_artista.get_numero_aparicoes_consecutivas())
+            row_infoartista_col7.metric(label='🏅 Número Pódios', value=info_artista.get_numero_podios())
+            row_infoartista_col8.metric(label='🏅 Pódios Consecutivos', value=info_artista.get_numero_podios_consecutivos())
+
+        with row_videos:
+
+            st.subheader('')
+            plotar_grafico_race(core.get_dados_cumulativos(load_data(False), 'Artista'),
+                              'Artista',
+                              'Top 10 Artistas com mais músicas nas edições')
+
+            plotar_grafico_race(core. get_dados_cumulativos(load_data(False), 'Genero'),
+                              'Genero',
+                              'Top 10 Gêneros Musicais com mais músicas nas edições')

charts.py

@@ -0,0 +1,155 @@
+import plotly.express as px
+import plotly.graph_objects as go
+import bar_chart_race as bcr
+
+def get_grafico_linha(df_data, xdata, ydata1, xlabel, ylabel, ylabel1, ydata2 = None, ylabel2 = None, reversed = False):
+    fig = px.line()
+    fig.update_layout(xaxis_type='category', xaxis_title = xlabel, yaxis_title=ylabel, separators=',.')
+    fig.add_scatter(x=df_data[xdata], y=df_data[ydata1], name=ylabel1)
+    if (ydata2 != None):
+        fig.add_scatter(x=df_data[xdata], y=df_data[ydata2], name=ylabel2)
+    fig.update_traces(hovertemplate=xlabel + ': %{x}<br> Valor: %{y}<extra></extra>')
+    if (reversed):
+        fig.update_layout(yaxis=dict(autorange='reversed'))
+
+    return fig
+
+def get_grafico_barra(df_data, xdata, ydata, xlabel, ylabel, x_diagonal=False):
+    fig = px.bar(df_data, x=xdata, y=ydata, text_auto=True)
+    fig.update_layout(xaxis_type='category', xaxis_title = xlabel, yaxis_title=ylabel, separators=',.')
+    fig.update_traces(marker_color='#C50B11', hovertemplate=xlabel + ": %{x}<br>" + ylabel + ": %{y}", textangle=0)
+    if x_diagonal:
+        fig.update_xaxes(tickangle=-45)
+    if (df_data.select_dtypes(include='datetime').columns.size > 0):
+        fig.update_layout(yaxis_tickformat="%M:%S")
+
+    return fig
+
+def get_grafico_barra_horizontal(df_data, xdata, ydata, xlabel, ylabel, x_diagonal=False):
+    df = df_data.sort_values(xdata, ascending = True)
+
+    fig = go.Figure(go.Bar(
+        x = df[xdata],
+        y = df[ydata],
+        hoverinfo = 'all',
+        name='',
+        textposition = 'outside',
+        texttemplate='%{x}',
+        hovertemplate = xlabel + ": %{x}<br>" + ylabel + ": %{y}",
+        orientation = 'h',
+        marker=dict(color='#C50B11'))
+    )
+
+    return fig
+
+def get_grafico_barra_stacked(df_data, xdata, ydata, ldata, xlabel, ylabel, llabel):
+    fig = px.bar(df_data, x=xdata, y=ydata, color=ldata, color_discrete_sequence=px.colors.qualitative.Dark24, barmode='stack')
+    fig.update_layout(xaxis_type='category', xaxis_title = xlabel, yaxis_title=ylabel, legend_title=llabel, legend_traceorder="reversed")
+    fig.update_traces(hovertemplate='%{fullData.name}<br>' + xlabel + ": %{label}<br>" + ylabel + ": %{value}<extra></extra>")
+    fig.update_xaxes(categoryorder='array', categoryarray=df_data.sort_values(xdata)[xdata].to_list())
+
+    return fig
+
+def get_grafico_pizza(df_data, valor, nomes, label_valor, label_nomes):
+    fig = px.pie(df_data, values=valor, names=nomes)
+    fig.update_traces(textposition='inside', textinfo='percent+label', hovertemplate=label_nomes + ": %{label}<br>" + label_valor + ": %{value}<br>" + 'Percentual' + ": %{percent}<br>")
+    fig.update_layout(
+        separators=',.',
+        uniformtext_minsize=12, uniformtext_mode='hide',
+        legend=dict(font=dict(size=14)),
+        margin=dict(
+            l=0,
+            r=0,
+            b=20,
+            t=50,
+            pad=0
+        ))
+
+    return fig
+
+def get_mapa(df_data, locations, color, hover_name, title):
+    fig = px.choropleth(df_data,
+                        locationmode="country names",
+                        locations=locations,
+                        color=color,
+                        hover_name=hover_name,
+                        color_continuous_scale = px.colors.sequential.YlOrRd, projection='natural earth')
+
+    fig.update_layout(coloraxis_colorbar=dict(title=title))
+
+    return fig
+
+def get_mapa_calor(df_data, xhover, yhover, zhover, xlabel, ylabel):
+    fig = go.Figure(data=go.Heatmap(
+                        z=df_data,
+                        x=df_data.columns,
+                        y=df_data.index,
+                        text=df_data,
+                        colorscale='viridis',
+                        reversescale=True,
+                        name="",
+                        hovertemplate= xhover + ': %{x}<br>' + yhover + ': %{y}<br>' + zhover + ': %{z}',
+                        texttemplate="%{text}"))
+
+    fig.update_layout(xaxis_type='category',
+                  xaxis_title = xlabel,
+                  yaxis_title = ylabel,
+                  height=55*len(df_data.index),
+                  dragmode=False,
+                  clickmode='none',
+                  showlegend=False)
+
+    fig.update_yaxes(tickvals=df_data.index, ticktext=[label + '  ' for label in df_data.index])
+    fig['layout']['yaxis']['autorange'] = "reversed"
+
+    return fig
+
+def get_analise_edicao_treemap(df_data, xdata, ydata, xlabel, ylabel):
+    fig = px.treemap(df_data, path=[px.Constant('Todos'), xdata], values=ydata, color=xdata, hover_data=[xdata])
+    fig.update_layout(margin = dict(t=50, l=25, r=25, b=25))
+    fig.update_traces(hovertemplate=xlabel + ": %{label}<br>" + ylabel + ": %{value}")
+
+    return fig
+
+def gerar_grafico_race(df_data, atributo, titulo):
+    df_values, df_ranks = bcr.prepare_long_data(df_data, index='Ano', columns=atributo, values='Count', steps_per_period=1)
+    return bcr.bar_chart_race(df_values,
+                              n_bars=10,
+                              steps_per_period=15,
+                              period_length=1000,
+                              title = titulo,
+                              period_template='{x:.0f}',
+                              bar_texttemplate='{x:.0f}',
+                              tick_template='{x:.0f}',
+                              fixed_max=True,
+                              filter_column_colors=True).data
+
+def get_grafico_slope(df_data, xlabel, xdata1, xdata2, ydata1, ydata2, legend1, legend2, title):
+    fig = go.Figure()
+
+    for _, row in df_data.iterrows():
+        fig.add_trace(go.Scatter(
+            y=[row[ydata1], row[ydata2]],
+            mode='lines+markers+text',
+            name=f"{row[legend1]} - {row[legend2]}",
+            text=[int(row[xdata1]), int(row[xdata2])],
+            textposition='bottom right',
+            line=dict(width=2),
+            hoverinfo='none',
+        ))
+
+    fig.update_layout(yaxis=dict(autorange='reversed', title=title, showticklabels=False),
+                      xaxis=dict(
+                            tickvals=[0, 1],
+                            ticktext=[xdata1,xdata2],
+                            title=xlabel
+                            ),
+                      height=600,
+                      legend=dict(
+                        orientation="h",  
+                        yanchor="bottom", 
+                        y=-0.3,           
+                        xanchor="center", 
+                        x=0.5             
+                    ))
+    return fig

components.py

@@ -0,0 +1,38 @@
+import streamlit as st
+import streamlit.components.v1 as components
+
+css_file = './resources/style.css'
+
+@st.cache_data
+def load_css():
+    with open(css_file) as f:
+        return f'<style>{f.read()}</style>'
+
+def top10(df_data):
+    html = load_css()
+    html+="""
+
+      <div class="list">
+          <div class="list__body">
+            <table class="list__table">
+              <tbody>
+    """
+
+    for index, row in df_data.iterrows():
+        html += '<tr class="list__row"><td class="list__cell"><span class="list__value">' + str(row.Posicao_Atual) +'</span></td>'
+        html += '<td class="list__cell"><span class="list__value">'+row.Musica+'</span><small class="list__label"></small></td>'
+        html += '<td class="list__cell"><span class="list__value">'+row.Artista+'</span><small class="list__label"></small>'
+        if (row.Variacao > 0):
+            html += '</td><td class="list__cell list__icon__green">▲ ' + str(row.Variacao) + '</td></tr>'
+        elif (row.Variacao < 0):
+            html += '</td><td class="list__cell list__icon__red">▼ ' + str(row.Variacao * -1) + '</td></tr>'
+        else:
+            html += '</td><td class="list__cell list__icon__grey">■ 0</td></tr>'
+
+    html+="""
+            </tbody></table>
+          </div>
+        </div>
+
+    """
+    return components.html(html, height=600, width=650)

core_functions.py

@@ -0,0 +1,418 @@
+import pandas as pd
+import numpy as np
+import io
+import time
+
+#Configuração
+pd.set_option("styler.render.max_elements", 350000)
+dataset_file = './data/500+.csv'
+predictions_file = './data/predicao_proximo_ano.csv'
+
+#Inicialização
+def load_data(agregar_pinkfloyd):
+    df_data = pd.read_csv(dataset_file)
+    df_data['Id'] = range(1, len(df_data) + 1)
+    df_data['Edicao'] = df_data.Ano.astype(str).str[-2:] + "-" + (df_data.Ano +1).astype(str).str[-2:]
+    df_data['Data_Lancamento_Album'] = pd.to_datetime(df_data['Data_Lancamento_Album'])
+    df_data['Decada_Lancamento_Album'] = df_data['Data_Lancamento_Album'].dt.year.apply(get_decada)
+    df_data['Duracao'] = df_data.loc[:,'Duracao'].fillna(value=0)
+    df_data['Duracao_Formatada'] = df_data.apply(lambda row: time.strftime("%M:%S", time.gmtime(row['Duracao'])), axis=1)
+    if (agregar_pinkfloyd):
+        df_data.loc[df_data['Musica'].str.contains('Another Brick', na=False), 'Musica'] = 'Another Brick in the Wall'
+        df_data.loc[df_data['Musica'].str.contains('Another Brick', na=False), 'Duracao'] = 508
+
+    return df_data
+
+def load_predicoes():
+    df_data = pd.read_csv(predictions_file)
+    return df_data
+
+#Funções
+def get_decada(ano):
+    return 'Anos ' + str(ano)[2] + '0'
+
+def listar_edicoes(df_data):
+    return np.array(np.unique(df_data.Edicao).tolist())
+
+def listar_posicoes(df_data):
+    return np.unique(df_data.Posicao).tolist()
+
+def listar_anos_lancamento(df_data):
+    return np.unique(df_data.Data_Lancamento_Album.dropna().dt.year.apply(lambda x: f'{x:.0f}')).tolist()
+
+def listar_anos_edicoes(df_data):
+    return np.array(np.unique(df_data.Ano).tolist())
+
+def filtrar_edicao(df_data, edicao_inicial, edicao_final):
+    edicoes = np.unique(df_data.Edicao).tolist()
+    indice_inicial = edicoes.index(edicao_inicial)
+    indice_final = edicoes.index(edicao_final)+1
+    edicoes_selecionadas = edicoes[indice_inicial:indice_final]
+    return df_data[df_data['Edicao'].isin(edicoes_selecionadas)]
+
+def filtrar_posicoes(df_data, posicao_inicial, posicao_final):
+    posicoes = list(range(posicao_inicial, posicao_final + 1))
+    return df_data[df_data['Posicao'].isin(posicoes)]
+
+def filtrar_anos(df_data, ano_inicial, ano_final):
+    anos = list(range(int(ano_inicial), int(ano_final) + 1))
+    return df_data[df_data['Data_Lancamento_Album'].dt.year.isin(anos)]
+
+def filtrar_inconsistencias(df_data):
+    return df_data.loc[(df_data['Artista'] != '???') & (df_data['Musica'].str.len() > 0) & (df_data['Observacao'] != 'repetida')]
+
+def get_primeiro_ano(df_data):
+    return df_data.sort_values(by='Ano').head(1)['Ano']
+
+def get_ultimo_ano(df_data):
+    return df_data.sort_values(by='Ano').tail(1)['Ano']
+
+def get_primeira_edicao(df_data):
+    return df_data.sort_values(by='Ano').head(1)['Edicao']
+
+def get_ultima_edicao(df_data):
+    return df_data.sort_values(by='Ano').tail(1)['Edicao']
+
+def get_primeiro_ano_lancamento(df_data):
+    return df_data.dropna(subset=['Musica']).sort_values(by = 'Data_Lancamento_Album').head(1)['Data_Lancamento_Album'].dt.year
+
+def get_ultimo_ano_lancamento(df_data):
+    return df_data.dropna(subset=['Musica']).sort_values(by = 'Data_Lancamento_Album').tail(1)['Data_Lancamento_Album'].dt.year
+
+def get_total_musicas_distintas(df_data):
+    return len(get_musicas_distintas(df_data))
+
+def get_total_artistas_distintos(df_data):
+    return len(np.unique(df_data.Artista.dropna()).tolist())
+
+def get_total_albuns_distintos(df_data):
+    return len(np.unique(df_data.Album_Single.dropna().astype(str)).tolist())
+
+def get_total_paises_distintos(df_data):
+    return len(np.unique(df_data.Pais.dropna()).tolist())
+
+def get_total_generos_distintos(df_data):
+    return len(get_generos_distintos(df_data))
+
+def get_musicas_distintas(df_data):
+    return filtrar_inconsistencias(df_data).drop_duplicates(subset=['Artista', 'Musica', 'Observacao'])
+
+def get_generos_distintos(df_data):
+    return filtrar_inconsistencias(df_data).drop_duplicates(subset='Genero')
+
+def get_total_horas(df_data):
+    return np.sum(df_data.Duracao.dropna()) / 3600
+
+def get_dicionario_musicas(df_data):
+    df = (filtrar_inconsistencias(df_data)
+                .drop_duplicates(subset={'Artista', 'Musica'})
+                .apply(lambda row: (row['Musica'] + ' (' + row['Artista'] + ')', row['Id']), axis=1)
+                .sort_values()
+                .tolist())
+
+    return dict((y, x) for x, y in df)
+
+def get_dicionario_artistas(df_data):
+    df = (filtrar_inconsistencias(df_data)
+                .drop_duplicates('Artista')
+                .apply(lambda row: (row['Artista'], row['Artista']), axis=1)
+                .sort_values()
+                .tolist())
+    
+    return dict((y, x) for x, y in df)
+
+def get_acumulado_musicas_distintas(df_data):
+    edicoes = np.unique(df_data.Edicao).tolist()
+    distinta_acumulado_periodo = []
+    for e in edicoes:
+        distinta_acumulado_periodo.append(get_total_musicas_distintas(filtrar_edicao(df_data, edicoes[0], e)))
+    return pd.DataFrame({'Anos': edicoes, 'Acumulado': distinta_acumulado_periodo})
+
+def get_acumulado_generos_distintos(df_data):
+    edicoes = np.unique(df_data.Edicao).tolist()
+    distinto_acumulado_periodo = []
+    for e in edicoes:
+        distinto_acumulado_periodo.append(get_total_generos_distintos(filtrar_edicao(df_data, edicoes[0], e)))
+    return pd.DataFrame({'Anos': edicoes, 'Acumulado': distinto_acumulado_periodo})
+
+def get_musicas_ano_lancamento(df_data):
+    df_temp = get_musicas_distintas(df_data)
+    return pd.DataFrame(df_temp.groupby(df_temp['Data_Lancamento_Album'].dt.year).size().reset_index().rename(columns={0: 'Total_Musicas'}))
+
+def get_musicas_decada_lancamento(df_data):
+    df_temp = get_musicas_distintas(df_data)
+    df_temp['Total_Musicas'] = df_temp.groupby('Decada_Lancamento_Album')['Decada_Lancamento_Album'].transform('count')
+    return pd.DataFrame(df_temp.sort_values('Data_Lancamento_Album').groupby(['Decada_Lancamento_Album', 'Total_Musicas']).head(1))[['Decada_Lancamento_Album', 'Total_Musicas']]
+
+def get_musicas_todos_anos(df_data):
+    df = filtrar_inconsistencias(df_data).copy()
+    df['Count'] = df.groupby(['Artista', 'Musica', 'Observacao'], dropna=False)['Musica'].transform('count')
+    df['Musica'] = df.apply(lambda row: row['Artista'] + ' - ' + row['Musica'], axis=1)
+    df = df.loc[df['Count'] == df['Ano'].nunique()].sort_values(['Ano','Posicao'])
+
+    return pd.pivot(data=df, index='Musica', columns='Edicao', values='Posicao')
+
+def get_musicas_por_pais(df_data, agrupar_edicoes=False):
+    df = filtrar_inconsistencias(df_data)
+    if (agrupar_edicoes):
+        return df.groupby(['Country', 'Pais']).size().reset_index(name='Total_Musicas')
+    else:
+        return (df.groupby(['Edicao', 'Pais'])
+                  .size()
+                  .reset_index(name='Total_Musicas')
+                  .groupby(['Edicao', 'Pais'])
+                  .agg({'Total_Musicas': 'sum'})
+                  .reset_index()
+                  .sort_values(by='Edicao')
+                  .sort_values(by='Total_Musicas', ascending=True))
+
+def get_musicas_por_genero(df_data):
+    df = filtrar_inconsistencias(df_data)
+    return (df.groupby(['Edicao', 'Genero'])
+              .size()
+              .reset_index(name='Total_Musicas')
+              .groupby(['Edicao', 'Genero'])
+              .agg({'Total_Musicas': 'sum'})
+              .reset_index()
+              .sort_values(by='Edicao')
+              .sort_values(by='Total_Musicas', ascending=True))
+
+def get_musicas_media_posicao(df_data):
+    #Fórmula Si = wi * Ai + (1 - wi) * S, em que:
+    #wi = mi/mi+m_avg, sendo mi número total de aparições da música e m_avg média de todas as aparições de músicas
+    #Ai = média aritmética da posição da música
+    #S = média aritmética da posição de todas as músicas
+    #Si = média bayesiana da posição da música
+    #https://arpitbhayani.me/blogs/bayesian-average/
+
+    df_distintas = filtrar_inconsistencias(df_data.copy())
+
+    #Workaround devido a problema de index com NaN no pivot_table. Necessário preencher o que está NaN com um valor dummy para poder fazer o grouping
+    #https://github.com/pandas-dev/pandas/issues/3729
+    df_distintas['Observacao'] = df_distintas['Observacao'].fillna('dummy')
+
+    df_totalizador = (df_distintas
+        .groupby(['Artista', 'Musica', 'Observacao'], dropna=False)
+        .size()
+        .reset_index(name='Total_Aparicoes'))
+
+    m_avg = df_totalizador['Total_Aparicoes'].mean()
+
+    pivot_table = (pd.pivot_table(df_distintas,
+                                  index=['Artista', 'Musica', 'Observacao'],
+                                  columns='Ano',
+                                  values='Posicao',
+                                  margins=True,
+                                  margins_name = 'Media_Posicao'))
+
+    S = pivot_table.loc[('Media_Posicao', '', ''), 'Media_Posicao']
+
+    newdf = (df_distintas
+             .groupby(['Artista', 'Musica', 'Observacao'], dropna=False)
+             .size()
+             .reset_index(name='Total_Aparicoes'))
+
+    merged_df = pd.merge(df_totalizador, pivot_table, on = ['Artista', 'Musica', 'Observacao'])
+
+    merged_df['Media_Bayesiana_Posicao'] = get_bayesian_average(merged_df['Total_Aparicoes'], m_avg, merged_df['Media_Posicao'], S)
+
+    return merged_df.sort_values('Media_Bayesiana_Posicao')
+
+def get_bayesian_average(m, m_avg, A, S):
+    w = m/(m+m_avg)
+    return w * A + (1-w) * S
+
+def get_artistas_top_n(df_data, top_n):
+    df = filtrar_posicoes(df_data, 1, top_n)
+    df = (filtrar_inconsistencias(df)
+          .groupby('Artista')
+          .size()
+          .sort_values(ascending=False)
+          .reset_index(name='Total_Aparicoes'))
+    return df
+
+def get_musicas_top_n(df_data, top_n):
+    df = filtrar_posicoes(df_data, 1, top_n)
+    df = (filtrar_inconsistencias(df)
+          .groupby(['Artista', 'Musica'])
+          .size()
+          .sort_values(ascending=False)
+          .reset_index(name='Total_Aparicoes'))
+    return df
+
+def get_albuns_top_n(df_data, top_n):
+    df = filtrar_posicoes(df_data, 1, top_n)
+    df = (filtrar_inconsistencias(df)
+          .groupby(['Artista', 'Album_Single'])
+          .size()
+          .sort_values(ascending=False)
+          .reset_index(name='Total_Aparicoes'))
+    return df
+
+def get_generos_top_n(df_data, top_n):
+    df = filtrar_posicoes(df_data, 1, top_n)
+    df = (filtrar_inconsistencias(df)
+          .groupby('Genero')
+          .size()
+          .sort_values(ascending=False)
+          .reset_index(name='Total_Aparicoes'))
+    return df
+
+def get_artistas_posicoes_semelhantes_top_n(df_data, top_n):
+    def analisar_retorno(grupo):
+        grupo = grupo.sort_values('Ano')
+        grupo['Posicao_Anterior'] = grupo['Posicao'].shift(1)
+        return grupo
+
+    df = df_data.groupby('Musica', group_keys=False)[['Ano', 'Posicao', 'Artista', 'Musica']].apply(analisar_retorno).dropna(subset=['Posicao_Anterior'])
+    df['Posicao_Semelhante'] = np.abs(df['Posicao'] - df['Posicao_Anterior']) <= 5
+
+    df = (df.groupby('Artista')['Posicao_Semelhante']
+                            .mean()
+                            .reset_index())
+
+    return df.sort_values(by=['Posicao_Semelhante', 'Artista'], ascending=[False, True]).head(top_n)
+
+def get_top_n_musicas_media_posicao(df_data, top_n):
+    df = get_musicas_media_posicao(df_data).loc[:,['Artista', 'Musica']]
+    df['Posicao'] = range(1, len(df) + 1)
+    return df[['Posicao', 'Artista', 'Musica']].head(top_n).set_index('Posicao')
+
+def get_top_n_todas_edicoes(df_data, top_n):
+    edicoes = np.unique(df_data.Edicao)
+    edicao_inicial = edicoes[0]
+    edicao_anterior = edicoes[len(edicoes) -2]
+    df1 = get_top_n_musicas_media_posicao(df_data, top_n).reset_index()
+    df2 = get_top_n_musicas_media_posicao(filtrar_edicao(df_data, edicao_inicial, edicao_anterior), 100).reset_index()
+
+    merged_df = pd.merge(df1, df2, how='left', on = ['Artista', 'Musica'], suffixes=('_Atual', '_Anterior'))
+    merged_df['Variacao'] = merged_df['Posicao_Anterior'] - merged_df['Posicao_Atual']
+
+    return merged_df
+
+def get_melhor_posicao_genero(df_data):
+    df = df = df_data.sort_values('Ano')
+    indexes = df.groupby(['Genero'])['Posicao'].idxmin()
+    return df.loc[indexes, ['Genero', 'Posicao', 'Edicao']]
+
+def get_analise_edicao(df_data, medida, analise):
+    agregadores = {"Musica_Artista":['Artista', 'Edicao'],
+                      "Album_Artista":['Album_Single', 'Edicao'],
+                      "Musica_Genero":['Genero', 'Edicao'],
+                      "Genero_Pais":['Pais','Edicao'],
+                      "Duracao":['Duracao','Edicao']}
+
+    dimensoes = {"Musica_Artista":'Musica',
+                      "Album_Artista":'Musica',
+                      "Musica_Genero":'Musica',
+                      "Genero_Pais":'Genero',
+                      "Duracao":'Duracao'}
+
+    agregador = agregadores[analise]
+    dimensao = dimensoes[analise]
+    index_name = 'Contagem'
+
+    df =  filtrar_inconsistencias(df_data)
+    if (dimensao != 'Duracao'):
+        df = df.groupby(agregador)[dimensao].count().reset_index(name=index_name)
+    else:
+        index_name = dimensao
+
+    match medida:
+        case 'Média':
+            df = df.groupby('Edicao')[index_name].mean().reset_index(name=medida)
+        case 'Mediana':
+            df = df.groupby('Edicao')[index_name].median().reset_index(name=medida)
+        case 'Máximo':
+            df = df.groupby('Edicao')[index_name].max().reset_index(name=medida)
+        case default:
+            df = df
+
+    if (dimensao == 'Duracao'):
+        df[medida] = pd.to_datetime(df[medida], unit='s')
+
+    return np.around(df,2)
+
+def get_idade_por_edicao(df_data):
+    df = df_data.copy()
+    df = filtrar_inconsistencias(df)
+    df['Idade_Lancamento'] = df['Ano'] + 1 - df['Data_Lancamento_Album'].dt.year
+
+    df = df.loc[:,['Edicao', 'Idade_Lancamento']]
+    df['Media_Idade_Lancamento'] = df.groupby('Edicao')['Idade_Lancamento'].transform('mean').round(2)
+    df['Mediana_Idade_Lancamento'] = df.groupby('Edicao')['Idade_Lancamento'].transform('median').round(0)
+
+    return df.groupby(['Edicao', 'Media_Idade_Lancamento', 'Mediana_Idade_Lancamento']).size().reset_index()
+
+def get_onehit_por_edicao(df_data):
+    df = df_data.copy()
+    df = filtrar_inconsistencias(df)
+
+    contagem = get_musicas_distintas(df).groupby('Artista').count().reset_index()[['Artista', 'Ano']]
+    contagem.columns = ['Artista', 'Count']
+
+    one_hit_wonders = contagem[contagem['Count'] == 1].sort_values(by='Artista')
+    one_hit_wonders = (pd.merge(df, one_hit_wonders[['Artista']], on='Artista', how='inner')
+                        .groupby('Edicao')['Artista']
+                        .nunique()
+                        .reset_index(name='One_Hit_Wonders'))
+
+    artistas_recorrentes = contagem[contagem['Count'] > 1].sort_values(by='Count', ascending=False)
+    artistas_recorrentes = (pd.merge(df, artistas_recorrentes[['Artista']], on='Artista', how='inner')
+                            .groupby('Edicao')['Artista']
+                            .nunique()
+                            .reset_index(name='Recorrentes'))
+
+    return pd.merge(one_hit_wonders, artistas_recorrentes, on='Edicao', how='outer').fillna(0)
+
+
+def get_dados_cumulativos(df_data, atributo):
+    df_data = filtrar_inconsistencias(df_data)
+    df_data = (df_data.groupby(['Ano', atributo])
+                  .size()
+                  .reset_index(name='Count')
+                  .groupby(['Ano', atributo])['Count']
+                  .sum()
+                  .groupby(level=atributo)
+                  .cumsum()
+                  .reset_index())
+    df_data = df_data.sort_values(by='Count', ascending=False).groupby('Ano').head(len(df_data))
+
+    return df_data
+
+def get_variacao_entre_anos(df, ano_inicial, ano_final, quantidade_musicas, quedas):
+    anos_para_comparar = [ano_inicial, ano_final]
+
+    df_sorted = df.sort_values(by=['Musica', 'Artista', 'Ano'])
+    df_sorted = df_sorted[df_sorted['Ano'].isin(anos_para_comparar)]
+
+    pivot = df_sorted.pivot_table(index=['Musica', 'Artista'], columns='Ano', values='Posicao').reset_index()
+
+    pivot.columns.name = None
+    pivot = pivot.rename(columns={
+        anos_para_comparar[0]: ano_inicial,
+        anos_para_comparar[1]: ano_final
+    })
+
+    pivot['Variacao'] = pivot[ano_inicial] - pivot[ano_final]
+
+    if (quedas):
+        top_n = pivot.sort_values(by='Variacao').head(quantidade_musicas)
+        top_n['Posicao_Anterior'] = top_n[ano_inicial] *1.5
+        top_n['Posicao_Atual'] = top_n[ano_final]
+    else:
+        top_n = pivot.sort_values(by='Variacao', ascending=False).head(quantidade_musicas)
+        top_n['Posicao_Anterior'] = top_n[ano_inicial]
+        top_n['Posicao_Atual'] = top_n[ano_final] *1.5
+
+    return top_n
+
+def get_predicoes(df):
+    df = df[["posicao_ranking", "Artista", "Musica"]].head(500)
+    return df
+
+def get_probabilidades(df):
+    df = df.sort_values(by=['prob_aparecer', 'Artista', 'Musica'], ascending=[False, True, True])
+    df["prob_aparecer"] = df["prob_aparecer"] * 100
+    df = df[["Artista", "Musica", "prob_aparecer"]]
+    return df

data/500+_openrefine.tar.gz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89e36f8063852d7d46e092b67eee32cfcc96962e08366e3143a26d5d47675f46
+size 2554300

data/raw/500+_raw.xlsx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:18c72765e769e01f1bbd231470109d622f539e9997a5b3257965c18634e03df7
+size 666557

info.py

@@ -0,0 +1,204 @@
+import json
+import pandas as pd
+import numpy as np
+
+class InfoBase:
+
+    def _listar_podios(self, df):
+        return df[df['Posicao'].isin({1,2,3})]
+    
+    def _contar_consecutivos(self, df):
+        df = df.reset_index()
+        diff = df['Ano'] + df.index
+        return df.groupby(diff)['Ano'].size().max()
+    
+    def get_melhor_posicao(self):
+        return np.min(self.df.Posicao)
+    
+    def get_pior_posicao(self):
+        return np.max(self.df.Posicao)
+    
+    def get_numero_aparicoes_consecutivas(self):        
+        return self._contar_consecutivos(self.df)
+    
+    def get_numero_podios_consecutivos(self):
+        return np.nan_to_num(self._contar_consecutivos(self._listar_podios(self.df))).astype('int')
+
+    def get_edicao_melhor_posicao(self):
+        return "Edição " + self.df[self.df['Posicao'] == self.get_melhor_posicao()].Edicao.values[-1]
+
+    def get_edicao_pior_posicao(self):
+        return "Edição " + self.df[self.df['Posicao'] == self.get_pior_posicao()].Edicao.values[-1]
+
+class InfoEdicao:
+
+    def __init__(self, df_data, ano):
+        self.df = df_data[df_data['Ano'] == ano]
+
+    def get_musica_posicao(self, posicao):
+        df_filtrado = self.df[self.df['Posicao'] == posicao]
+        return df_filtrado.Artista.values[0] + ' - ' + df_filtrado.Musica.values[0]
+
+    def get_musica_menor_duracao(self):
+        df_filtrado = self.df.dropna(subset='Musica').sort_values(by='Duracao').head(1)
+        return df_filtrado.Artista.values[0] + ' - ' + df_filtrado.Musica.values[0] + ' (' + df_filtrado.Duracao_Formatada.values[0] + ')'
+
+    def get_musica_maior_duracao(self):
+        df_filtrado = self.df.dropna(subset='Musica').sort_values(by='Duracao').tail(1)
+        return df_filtrado.Artista.values[0] + ' - ' + df_filtrado.Musica.values[0] + ' (' + df_filtrado.Duracao_Formatada.values[0] + ')'
+
+    def get_top_artista(self):
+        top_artista = (self.df.groupby('Artista')
+                       .size()
+                       .reset_index(name='Count')
+                       .sort_values(by='Count', ascending=False))
+        top_artista = (top_artista[top_artista['Count'] == top_artista
+                                   .drop_duplicates(subset='Count')
+                                   .head(1)['Count']
+                                   .values[0]])
+        top_artista['Str'] = top_artista.Artista + ' (' + top_artista.Count.astype(str) + ')'
+        return ', '.join(top_artista.Str)
+
+    def get_top_album(self):
+        top_album = (self.df.groupby(['Album_Single', 'Artista'])
+                       .size()
+                       .reset_index(name='Count')
+                       .sort_values(by='Count', ascending=False))
+        top_album = (top_album[top_album['Count'] == top_album
+                                   .drop_duplicates(subset='Count')
+                                   .head(1)['Count']
+                                   .values[0]])
+        top_album['Str'] = top_album.Artista + ' - ' + top_album.Album_Single + ' (' + top_album.Count.astype(str) + ')'
+        return ', '.join(top_album.Str)
+
+    def get_top_genero(self):
+        top_genero = (self.df.groupby('Genero')
+                       .size()
+                       .reset_index(name='Count')
+                       .sort_values(by='Count', ascending=False))
+        top_genero = (top_genero[top_genero['Count'] == top_genero
+                                   .drop_duplicates(subset='Count')
+                                   .head(1)['Count']
+                                   .values[0]])
+        top_genero['Str'] = top_genero.Genero + ' (' + top_genero.Count.astype(str) + ')'
+        return ', '.join(top_genero.Str)
+
+    def get_repetidas(self):
+        df_repetidas = self.df[self.df['Observacao'] == 'repetida'].groupby('Observacao').size().reset_index(name='Count')
+        if df_repetidas.empty:
+            return 'Não'
+        else:
+            return 'Sim (' + str(df_repetidas.Count.values[0]) + ')'
+
+    def get_lista_paises(self):
+        return self.df.groupby(['Edicao', 'Pais']).size().reset_index(name='Quantidade')
+
+    def get_lista_generos(self):
+        return self.df.groupby(['Edicao', 'Genero']).size().reset_index(name='Quantidade')
+
+    def get_musicas(self):
+        df = self.df.sort_values(by='Data_Lancamento_Album')
+        df = df.loc[:, ['Data_Lancamento_Album', 'Artista', 'Musica']].reset_index()
+        df = df.rename(columns={"index": "unique_id", "Artista": "text", "Musica": "headline"})
+
+        df['year'] = df['Data_Lancamento_Album'].dt.year
+        df['month'] = df['Data_Lancamento_Album'].dt.month
+        df['day'] = df['Data_Lancamento_Album'].dt.day
+        df['start_date'] = df[['year', 'month', 'day']].to_dict(orient='records')
+        df['text'] = df[['headline', 'text']].to_dict(orient='records')
+        df = df.drop(['Data_Lancamento_Album','year', 'month', 'day', 'headline'], axis=1).to_dict(orient='records')
+
+        return json.dumps({'events': df})
+
+    def get_range_data_lancamento(self):
+        return [(self.df.Data_Lancamento_Album.min() + pd.DateOffset(years=-3)).strftime('%Y-%m-%dT%H:%M:%SZ'),
+                (self.df.Data_Lancamento_Album.max() + pd.DateOffset(years=3)).strftime('%Y-%m-%dT%H:%M:%SZ')]
+
+class InfoMusica(InfoBase):
+
+    def __init__(self, df_data, id_musica):
+        musica = df_data[df_data['Id'] == id_musica].Musica
+        artista = df_data[df_data['Id'] == id_musica].Artista
+
+        self.df = df_data.loc[(df_data['Artista'] == artista.values[0]) & (df_data['Musica'] == musica.values[0])]
+
+    def get_numero_aparicoes(self):
+        return np.size(self.df.Posicao)
+    
+    def get_numero_podios(self):
+        return np.size(self._listar_podios(self.df)['Musica'])
+
+    def get_decada(self):
+        return self.df.Decada_Lancamento_Album.values[0]
+
+    def get_posicao_media(self):
+        return np.mean(self.df.Posicao).round(0).astype(int)
+
+    def get_posicoes(self):
+        return self.df.sort_values(by='Ano', ascending=True)
+    
+class InfoArtista(InfoBase):
+    
+    def __init__(self, df_data, artista):
+        self.df = df_data.loc[(df_data['Artista'] == artista)]
+    
+    def get_total_musicas(self):
+        return np.size(self.df.Id)
+    
+    def get_total_edicoes(self):
+        return np.size(self.df['Edicao'].drop_duplicates())
+    
+    def get_media_musicas_por_edicao(self):
+        return (self.get_total_musicas()/self.get_total_edicoes())
+    
+    def get_numero_aparicoes_consecutivas(self):
+        return self._contar_consecutivos(self.df['Ano'].drop_duplicates())
+    
+    def get_numero_podios(self):
+        return np.size(self._listar_podios(self.df)['Artista'])
+
+class InfoCuriosidade:
+
+    def __init__(self, df_data):
+        self.df = df_data
+
+    def __agrupar_dataframe(self, agregador):
+        return self.df.groupby(agregador).size().reset_index(name = 'Count')
+
+    def get_primeiro_artista_br(self):
+        df = self.df[self.df['Pais'] == 'Brasil'].sort_values(['Ano', 'Posicao'], ascending=False).tail(1)
+        return [df.Artista.values[0], df.Ano.values[0], df.Posicao.values[0]]
+
+    def get_edicao_menos_artistas(self):
+        df = self.__agrupar_dataframe(['Edicao', 'Artista']).groupby('Edicao')['Count'].count().reset_index().sort_values('Count')
+        return [df.head(1).Edicao.values[0], df.head(1).Count.values[0]]
+
+    def get_edicao_mais_artistas(self):
+        df = self.__agrupar_dataframe(['Edicao', 'Artista']).groupby('Edicao')['Count'].count().reset_index().sort_values('Count')
+        return [df.tail(1).Edicao.values[0], df.tail(1).Count.values[0]]
+
+    def get_album_mais_musicas(self):
+        df = self.__agrupar_dataframe(['Album_Single', 'Artista']).sort_values('Count').tail(1)
+        return [df.Artista.values[0], df.Album_Single.values[0], df.Count.values[0], np.round(df.Count.values[0]/len(self.df)*100,2)]
+
+    def get_artista_mais_musicas_edicao(self):
+        df = self.__agrupar_dataframe(['Edicao', 'Artista']).sort_values('Count').tail(1)
+        return [df.Artista.values[0], df.Count.values[0], df.Edicao.values[0]]
+    
+    def get_one_hit_wonder(self):
+        df = self.df.drop_duplicates(subset=['Artista', 'Musica', 'Observacao']).groupby('Artista').count().reset_index()[['Artista', 'Ano']]
+        df.columns = ['Artista', 'Count']
+        one_hit_wonders = df[df['Count'] == 1].sort_values(by='Artista')
+        return [one_hit_wonders.shape[0], np.round(one_hit_wonders.shape[0]/df.shape[0]*100,2)]
+
+    def get_album_mais_musicas_edicao(self):
+        df = self.__agrupar_dataframe(['Edicao', 'Album_Single']).sort_values('Count').sort_values('Count').tail(1)
+        return [df.Album_Single.values[0], df.Count.values[0], df.Edicao.values[0]]
+
+    def get_artista_maior_percentual(self):
+        df = self.__agrupar_dataframe(['Artista']).sort_values('Count').tail(1)
+        return [df.Artista.values[0], df.Count.values[0], np.round(df.Count.values[0]/len(self.df)*100,2)]
+
+    def get_duracao(self):
+        df_filtrado = self.df.dropna(subset='Musica').sort_values(by='Duracao')
+        return [df_filtrado.head(1).Duracao_Formatada.values[0], df_filtrado.tail(1).Duracao_Formatada.values[0]]

notebooks/500-kissfm.ipynb

@@ -0,0 +1 @@
+{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":7630495,"sourceType":"datasetVersion","datasetId":4443244}],"dockerImageVersionId":30646,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"code","source":"import pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sb\nimport locale\n\n#Configuração\n#locale.setlocale(locale.LC_ALL, 'pt_BR.UTF-8')\n\nclass Info:\n    \n    def __init__(self, df_data, ano):\n        self.df = df_data[df_data['Ano'] == ano]\n        \n    def get_musica_posicao(self, posicao):\n        df_filtrado = self.df[self.df['Posicao'] == posicao]\n        return df_filtrado.Artista.values[0] + ' - ' + df_filtrado.Musica.values[0]\n    \n    def get_top_artista(self):\n        top_artista = (self.df.groupby('Artista')\n                       .size()\n                       .reset_index(name='Count')\n                       .sort_values(by='Count', ascending=False))\n        top_artista = (top_artista[top_artista['Count'] == top_artista\n                                   .drop_duplicates(subset='Count')\n                                   .head(1)['Count']\n                                   .values[0]])\n        top_artista['Str'] = top_artista.Artista + ' (' + top_artista.Count.astype(str) + ')'\n        return ', '.join(top_artista.Str)\n    \n    def get_top_album(self):\n        top_album = (self.df.groupby(['Album_Single', 'Artista'])\n                       .size()\n                       .reset_index(name='Count')\n                       .sort_values(by='Count', ascending=False))\n        top_album = (top_album[top_album['Count'] == top_album\n                                   .drop_duplicates(subset='Count')\n                                   .head(1)['Count']\n                                   .values[0]])\n        top_album['Str'] = top_album.Artista + ' - ' + top_album.Album_Single + ' (' + top_album.Count.astype(str) + ')'\n        return ', '.join(top_album.Str)\n    \n    def get_repetidas(self):\n        df_repetidas = self.df[self.df['Observacao'] == 'repetida'].groupby('Observacao').size().reset_index(name='Count')\n        if df_repetidas.empty:\n            return 'Não'\n        else:\n            return 'Sim (' + str(df_repetidas.Count.values[0]) + ')'\n\ndef get_decada(ano):\n    return 'Anos ' + str(ano)[2] + '0'\n\n#Inicialização\ndf_listagem = pd.read_csv(\"/kaggle/input/500-kiss/500.csv\")\ndf_listagem['Id'] = range(1, len(df_listagem) + 1)\ndf_listagem['Ano_Periodo'] = df_listagem.Ano.astype(str).str[-2:] + \"-\" + (df_listagem.Ano +1).astype(str).str[-2:]\ndf_listagem['Data_Lancamento_Album'] = pd.to_datetime(df_listagem['Data_Lancamento_Album'])\ndf_listagem['Decada_Lancamento_Album'] = df_listagem['Data_Lancamento_Album'].dt.year.apply(get_decada)\n\n#Funções\ndef filtrar_periodo(df_data, periodo_inicial, periodo_final):\n    periodos = np.unique(df_data.Ano_Periodo).tolist()\n    indice_inicial = periodos.index(periodo_inicial)\n    indice_final = periodos.index(periodo_final)+1\n    periodos_selecionados = periodos[indice_inicial:indice_final]\n    return df_data[df_data['Ano_Periodo'].isin(periodos_selecionados)]\n\ndef filtrar_posicoes(df_data, posicao_inicial, posicao_final):\n    posicoes = list(range(posicao_inicial, posicao_final + 1))\n    return df_data[df_data['Posicao'].isin(posicoes)]\n\ndef filtrar_inconsistencias(df_data):\n    return df_data.loc[(df_data['Artista'] != '???') & (df_data['Musica'].str.len() > 0) & (df_data['Observacao'] != 'repetida')]\n\ndef get_primeiro_ano(df_data):\n    return df_data.sort_values(by='Ano').head(1)['Ano']\n\ndef get_ultimo_ano(df_data):\n    return df_data.sort_values(by='Ano').tail(1)['Ano']\n\ndef get_primeiro_ano_periodo(df_data):\n    return df_data.sort_values(by='Ano').head(1)['Ano_Periodo']\n\ndef get_ultimo_ano_periodo(df_data):\n    return df_data.sort_values(by='Ano').tail(1)['Ano_Periodo']\n\ndef get_primeiro_ano_lancamento(df_data):\n    return df_listagem.dropna(subset=['Musica']).sort_values(by = 'Data_Lancamento_Album').head(1)['Data_Lancamento_Album'].dt.year\n\ndef get_ultimo_ano_lancamento(df_data):\n    return df_listagem.dropna(subset=['Musica']).sort_values(by = 'Data_Lancamento_Album').tail(1)['Data_Lancamento_Album'].dt.year\n\ndef get_total_musicas_distintas(df_data):\n    return len(get_musicas_distintas(df_data))\n\ndef get_musicas_distintas(df_data):\n    return filtrar_inconsistencias(df_data).drop_duplicates(subset=['Artista', 'Musica', 'Observacao'])\n\ndef get_acumulado_musicas_distintas(df_data):\n    periodos = np.unique(df_data.Ano_Periodo).tolist()\n    distinta_acumulado_periodo = []\n    for p in periodos:\n        distinta_acumulado_periodo.append(get_total_musicas_distintas(filtrar_periodo(df_data, periodos[0], p)))\n    return pd.DataFrame({'Anos': periodos, 'Acumulado': distinta_acumulado_periodo})\n\ndef get_musicas_ano_lancamento(df_data):\n    df_temp = get_musicas_distintas(df_data)\n    return pd.DataFrame(df_temp.groupby(df_temp['Data_Lancamento_Album'].dt.year).size().reset_index().rename(columns={0: 'Total_Musicas'}))\n\ndef get_musicas_decada_lancamento(df_data):\n    df_temp = get_musicas_distintas(df_data)\n    df_temp['Total_Musicas'] = df_temp.groupby('Decada_Lancamento_Album')['Decada_Lancamento_Album'].transform('count')\n    return pd.DataFrame(df_temp.sort_values('Data_Lancamento_Album').groupby(['Decada_Lancamento_Album', 'Total_Musicas']).head(1))[['Decada_Lancamento_Album', 'Total_Musicas']]\n\ndef get_musicas_todos_anos(df_data):\n    df = filtrar_inconsistencias(df_data).copy()\n    df['Count'] = df.groupby(['Artista', 'Musica', 'Observacao'], dropna=False)['Musica'].transform('count')\n    df['Musica'] = df.apply(lambda row: row['Artista'] + ' - ' + row['Musica'], axis=1)\n    df = df.loc[df['Count'] == 24].sort_values(['Ano','Posicao'])\n\n    return pd.pivot(data=df, index='Musica', columns='Ano_Periodo', values='Posicao')\n\ndef get_musicas_media_posicao(df_data):\n    #Fórmula Si = wi * Ai + (1 - wi) * S, em que:\n    #wi = mi/mi+m_avg, sendo mi número total de aparições da música e m_avg média de todas as aparições de músicas\n    #Ai = média aritmética da posição da música\n    #S = média aritmética da posição de todas as músicas\n    #Si = média bayesiana da posição da música\n    #https://arpitbhayani.me/blogs/bayesian-average/\n    \n    df_distintas = filtrar_inconsistencias(df_data.copy())\n    \n    #Workaround devido a problema de index com NaN no pivot_table. Necessário preencher o que está NaN com um valor dummy para poder fazer o grouping\n    #https://github.com/pandas-dev/pandas/issues/3729\n    df_distintas['Observacao'] = df_distintas['Observacao'].fillna('dummy')\n    \n    df_totalizador = (df_distintas\n        .groupby(['Artista', 'Musica', 'Observacao'], dropna=False)\n        .size()\n        .reset_index(name='Total_Aparicoes'))\n\n    m_avg = df_totalizador['Total_Aparicoes'].mean()\n    \n    pivot_table = (pd.pivot_table(df_distintas, \n                                  index=['Artista', 'Musica', 'Observacao'], \n                                  columns='Ano', \n                                  values='Posicao', \n                                  margins=True, \n                                  margins_name = 'Media_Posicao'))\n    \n    S = pivot_table.loc[('Media_Posicao', '', ''), 'Media_Posicao']\n\n    newdf = (df_distintas\n             .groupby(['Artista', 'Musica', 'Observacao'], dropna=False)\n             .size()\n             .reset_index(name='Total_Aparicoes'))\n    \n    merged_df = pd.merge(df_totalizador, pivot_table, on = ['Artista', 'Musica', 'Observacao'])\n\n    merged_df['Media_Bayesiana_Posicao'] = get_bayesian_average(merged_df['Total_Aparicoes'], m_avg, merged_df['Media_Posicao'], S)\n    \n    return merged_df.sort_values('Media_Bayesiana_Posicao')\n\ndef get_bayesian_average(m, m_avg, A, S):\n    w = m/(m+m_avg)\n    return w * A + (1-w) * S\n\ndef get_artistas_top_n(df_data, top_n):\n    df = filtrar_posicoes(df_data, 1, top_n)\n    df = (filtrar_inconsistencias(df)\n          .groupby('Artista')\n          .size()\n          .sort_values(ascending=False)\n          .reset_index(name='Total_Aparicoes'))\n    return df\n\ndef get_musicas_top_n(df_data, top_n):\n    df = filtrar_posicoes(df_data, 1, top_n)\n    df = (filtrar_inconsistencias(df)\n          .groupby('Musica')\n          .size()\n          .sort_values(ascending=False)\n          .reset_index(name='Total_Aparicoes'))\n    return df\n\ndef get_analise_periodo(df_data, medida, agregador):\n    df =  filtrar_inconsistencias(df_data)\n    df = df.groupby(agregador)['Musica'].count().reset_index()\n    match medida:\n        case 'Contagem':\n            return df.groupby('Ano_Periodo').sum().reset_index()\n        case 'Média':\n            return df.groupby('Ano_Periodo')['Musica'].mean().reset_index()\n        case 'Mediana':\n            return df.groupby('Ano_Periodo')['Musica'].median().reset_index()\n        case 'Mínimo':\n            return df.groupby('Ano_Periodo')['Musica'].min().reset_index()\n        case 'Máximo':\n            return df.groupby('Ano_Periodo')['Musica'].max().reset_index()\n        case default:\n            return df\n\ndef plotar_grafico_barra(df_data, xdata, ydata, xlabel, ylabel, decimal=False, rotacao=0):\n    rc = {'figure.figsize':(12,4.5),\n      'axes.facecolor':'#0e1117',\n      'axes.edgecolor': '#0e1117',\n      'axes.labelcolor': 'white',\n      'figure.facecolor': '#0e1117',\n      'patch.edgecolor': '#0e1117',\n      'text.color': 'white',\n      'xtick.color': 'white',\n      'ytick.color': 'white',\n      'grid.color': 'grey',\n      'font.size' : 8,\n      'axes.labelsize': 12,\n      'xtick.labelsize': 8,\n      'ytick.labelsize': 12}\n\n    plt.rcParams.update(rc)\n    fig, ax = plt.subplots()\n\n    ax = sb.barplot(x=xdata, y=ydata, data=df_data, color = \"#b80606\")\n    ax.set(xlabel = xlabel, ylabel = ylabel)\n    plt.xticks(rotation=66,horizontalalignment=\"right\")\n    for p in ax.patches:\n        if decimal:\n            text = format(p.get_height(), '.2f')\n        else:\n            text = format(str(int(p.get_height())))\n        ax.annotate(text,\n              (p.get_x() + p.get_width() / 2., p.get_height()),\n                ha = 'center',\n                va = 'center',\n                xytext = (0, 18),\n                rotation = rotacao,\n                textcoords = 'offset points')\n    plt.show()\n    \ndef plotar_mapa_calor(df_data):\n    plt.figure(figsize=(20,9.5))\n    plt.tick_params(axis='both', which='major', labelsize=10, labelbottom = True, bottom=True, top = True, labeltop=True)\n    sb.heatmap(df_data, cmap='viridis_r', annot=True, cbar=False, fmt='g')\n    plt.show()\n\n# App\ndf_listagem_filtrada = filtrar_periodo(df_listagem, '00-01', '23-24')\ndf_listagem_filtrada = filtrar_posicoes(df_listagem_filtrada, 1, 500)\n\ntotal_musicas = df_listagem_filtrada.Id.nunique()\ntotal_musicas_distintas = get_total_musicas_distintas(df_listagem_filtrada)\ntotal_artistas = len(np.unique(df_listagem_filtrada.Artista.dropna()).tolist())\ntotal_albuns = len(np.unique(df_listagem_filtrada.Album_Single.dropna().astype(str)).tolist())\n\nstr_total_musicas = \"🎶 \" + locale.format_string(\"%d\", total_musicas, grouping = True) + \" músicas no total\"\nstr_total_musicas_distintas = \"🎵 \" + locale.format_string(\"%d\", total_musicas_distintas, grouping = True) + \" músicas diferentes\"\nstr_total_artistas = \"🧑‍🎤 \" + locale.format_string(\"%d\", total_artistas, grouping = True) + \" artista(s)\"\nstr_total_albuns = \"💿 \" + locale.format_string(\"%d\", total_albuns, grouping = True) + \" álbum(s)/single(s)\"\n\nprint(str_total_musicas, str_total_musicas_distintas, str_total_artistas, str_total_albuns, \"\\n\")\n\nget_musicas_media_posicao(df_listagem_filtrada)\n\nget_artistas_top_n(df_listagem, 3)\nget_artistas_top_n(df_listagem, 10)\n\nget_musicas_top_n(df_listagem, 3)\nget_musicas_top_n(df_listagem, 10)\n\ninfo = Info(df_listagem, 2000)\ninfo.get_musica_posicao(1)\ninfo.get_musica_posicao(500)\ninfo.get_top_artista()\ninfo.get_repetidas()\ninfo.get_top_album()\n\nplotar_grafico_barra(get_acumulado_musicas_distintas(df_listagem_filtrada), \"Anos\", \"Acumulado\", \"Anos\", \"Acumulado de Músicas distintas\")\n\nplotar_grafico_barra(get_musicas_ano_lancamento(df_listagem_filtrada), \"Data_Lancamento_Album\", \"Total_Musicas\", \"Anos\", \"Quantidade de Músicas distintas\")\n\nplotar_grafico_barra(get_musicas_decada_lancamento(df_listagem_filtrada), \"Decada_Lancamento_Album\", \"Total_Musicas\", \"Décadas\", \"Quantidade de Músicas distintas\")\n\nplotar_grafico_barra(get_analise_periodo(df_listagem_filtrada, \"Média\", ['Artista', 'Ano_Periodo']), \"Ano_Periodo\", \"Musica\", \"Anos\", \"Músicas por Artista\", True)\n\nplotar_grafico_barra(get_analise_periodo(df_listagem_filtrada, 'Média', ['Album_Single', 'Ano_Periodo']), \"Ano_Periodo\", \"Musica\", \"Anos\", \"Álbuns por Artista\", True)\n\nplotar_mapa_calor(get_musicas_todos_anos(df_listagem))","metadata":{"trusted":true},"execution_count":null,"outputs":[]}]}

notebooks/predicao_proximo_ano.ipynb

@@ -0,0 +1,462 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "8d71a4a8",
+   "metadata": {},
+   "source": [
+    "## 1. Configurações e carregamento do dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "62be5d5b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "dataset_file = '../data/500+.csv'\n",
+    "ano_predicao = 2025\n",
+    "\n",
+    "def filtrar_inconsistencias(df_data):\n",
+    "    return df_data.loc[(df_data['Artista'] != '???') & (df_data['Musica'].str.len() > 0) & (df_data['Observacao'] != 'repetida')]\n",
+    "\n",
+    "def load_data(agregar_pinkfloyd):\n",
+    "    df_data = pd.read_csv(dataset_file)\n",
+    "    df_data['Data_Lancamento_Album'] = pd.to_datetime(df_data['Data_Lancamento_Album'])\n",
+    "    df_data['Decada_Musica'] = (df_data['Data_Lancamento_Album'].dt.year // 10) * 10\n",
+    "    df_data['Ano_Musica'] = df_data['Data_Lancamento_Album'].dt.year\n",
+    "    df_data['Duracao'] = df_data.loc[:,'Duracao'].fillna(value=0)\n",
+    "    if (agregar_pinkfloyd):\n",
+    "        df_data.loc[df_data['Musica'].str.contains('Another Brick', na=False), 'Musica'] = 'Another Brick in the Wall'\n",
+    "        df_data.loc[df_data['Musica'].str.contains('Another Brick', na=False), 'Duracao'] = 508\n",
+    "\n",
+    "    df_data = df_data.drop(['Artista_Origem', 'Musica_Origem', 'Artista_Wikidata_ID', 'Artista_Wikidata', 'Artista_Wiki', 'Country', 'Genre', 'Musica_Wikidata_ID', 'Musica_Wikidata', 'Musica_Wiki', 'Album_Single_Wikidata_ID', 'Album_Single_Wikidata', 'Album_Single_Wiki', 'Data_Lancamento_Album'], axis=1)\n",
+    "    df_data.rename(columns={'Album_Single':'Album'}, inplace=True)\n",
+    "    df_data = filtrar_inconsistencias(df_data)\n",
+    "    return df_data\n",
+    "\n",
+    "df = load_data(True)\n",
+    "df = df[df['Ano'] < ano_predicao]\n",
+    "print(\"Dataset carregado com sucesso!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c8044620",
+   "metadata": {},
+   "source": [
+    "## 2. Identificador única da música"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "74bfdb24",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Preparando dados...\")\n",
+    "\n",
+    "# Criar identificador único: Artista-Musica-Observacao\n",
+    "df['id_musica'] = (df['Artista'].fillna('') + '|||' + \n",
+    "                    df['Musica'].fillna('') + '|||' + \n",
+    "                    df['Observacao'].fillna(''))\n",
+    "\n",
+    "# Garantir que Observacao seja tratada corretamente\n",
+    "df['Observacao'] = df['Observacao'].fillna('')\n",
+    "\n",
+    "print(f\"\\nTotal de músicas únicas: {df['id_musica'].nunique()}\")\n",
+    "print(f\"Total de registros: {len(df)}\")\n",
+    "\n",
+    "print(f\"\\nAno de previsão: {ano_predicao}\")\n",
+    "print(f\"Anos no dataset: {df['Ano'].min()} a {df['Ano'].max()}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0d49161e",
+   "metadata": {},
+   "source": [
+    "## 3. Engenharia de features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ec4f2c92",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def calcular_features_musica(df, ano_previsao):\n",
+    "    features_list = []\n",
+    "    \n",
+    "    # Obter todas as músicas únicas\n",
+    "    musicas_unicas = df['id_musica'].unique()\n",
+    "    \n",
+    "    for id_musica in musicas_unicas:\n",
+    "        df_musica = df[df['id_musica'] == id_musica].sort_values('Ano')\n",
+    "        \n",
+    "        # Informações básicas\n",
+    "        artista = df_musica['Artista'].iloc[0]\n",
+    "        musica = df_musica['Musica'].iloc[0]\n",
+    "        observacao = df_musica['Observacao'].iloc[0]\n",
+    "        pais = df_musica['Pais'].iloc[0] if 'Pais' in df_musica.columns else None\n",
+    "        genero = df_musica['Genero'].iloc[0] if 'Genero' in df_musica.columns else None\n",
+    "        \n",
+    "        # Anos de aparição\n",
+    "        anos_aparicao = df_musica['Ano'].values\n",
+    "        anos_totais = ano_previsao - df['Ano'].min()\n",
+    "        \n",
+    "        # 1. frequencia_aparicao: % de anos em que apareceu\n",
+    "        frequencia_aparicao = len(anos_aparicao) / anos_totais if anos_totais > 0 else 0\n",
+    "        \n",
+    "        # 2. streak_anos: Anos consecutivos (até o último ano)\n",
+    "        anos_ordenados = sorted(anos_aparicao, reverse=True)\n",
+    "        streak_anos = 0\n",
+    "        ano_esperado = ano_previsao - 1\n",
+    "        for ano in anos_ordenados:\n",
+    "            if ano == ano_esperado:\n",
+    "                streak_anos += 1\n",
+    "                ano_esperado -= 1\n",
+    "            else:\n",
+    "                break\n",
+    "        \n",
+    "        # 3. anos_desde_ultima: Anos desde última aparição\n",
+    "        ultimo_ano = max(anos_aparicao)\n",
+    "        anos_desde_ultima = ano_previsao - ultimo_ano - 1\n",
+    "        \n",
+    "        # 4. aparicao_unica: Flag binária\n",
+    "        aparicao_unica = 1 if len(anos_aparicao) == 1 else 0\n",
+    "        \n",
+    "        # 5. anos_desde_unica_aparicao\n",
+    "        anos_desde_unica_aparicao = anos_desde_ultima if aparicao_unica == 1 else 0\n",
+    "        \n",
+    "        # 6. dropout_score: Score de risco de dropout\n",
+    "        # Maior quando: aparição única antiga, ou muitos anos sem aparecer\n",
+    "        if aparicao_unica == 1:\n",
+    "            dropout_score = min(anos_desde_unica_aparicao / 10, 1.0)\n",
+    "        else:\n",
+    "            dropout_score = min(anos_desde_ultima / 5, 1.0) * (1 - frequencia_aparicao)\n",
+    "        \n",
+    "        # 7. forca_musica: Score composto de estabelecimento\n",
+    "        # Maior quanto mais frequente e recente\n",
+    "        forca_musica = (frequencia_aparicao * 0.5 + \n",
+    "                       (1 - min(anos_desde_ultima / 10, 1.0)) * 0.3 +\n",
+    "                       min(streak_anos / 5, 1.0) * 0.2)\n",
+    "        \n",
+    "        # 8. penalidade_one_hit: Penalidade para one-hit wonders\n",
+    "        penalidade_one_hit = anos_desde_unica_aparicao * 0.1 if aparicao_unica == 1 else 0\n",
+    "        \n",
+    "        # 9. volatilidade_posicao: Amplitude entre melhor e pior posição\n",
+    "        posicoes = df_musica['Posicao'].values\n",
+    "        volatilidade_posicao = max(posicoes) - min(posicoes) if len(posicoes) > 1 else 0\n",
+    "        \n",
+    "        # 10. consistencia: Regularidade nas aparições\n",
+    "        if len(anos_aparicao) > 1:\n",
+    "            gaps = np.diff(sorted(anos_aparicao))\n",
+    "            consistencia = 1 / (1 + np.std(gaps)) if len(gaps) > 0 else 1\n",
+    "        else:\n",
+    "            consistencia = 0\n",
+    "        \n",
+    "        # Estatísticas de posição\n",
+    "        posicao_media = df_musica['Posicao'].mean()\n",
+    "        melhor_posicao = df_musica['Posicao'].min()\n",
+    "        pior_posicao = df_musica['Posicao'].max()\n",
+    "        ultima_posicao = df_musica[df_musica['Ano'] == ultimo_ano]['Posicao'].iloc[0]\n",
+    "        \n",
+    "        # Tendência de posição (melhorando ou piorando)\n",
+    "        if len(posicoes) > 1:\n",
+    "            tendencia_posicao = posicoes[-1] - posicoes[0]  # negativo = melhorando\n",
+    "        else:\n",
+    "            tendencia_posicao = 0\n",
+    "        \n",
+    "        features_list.append({\n",
+    "            'id_musica': id_musica,\n",
+    "            'Artista': artista,\n",
+    "            'Musica': musica,\n",
+    "            'Observacao': observacao,\n",
+    "            'Pais': pais,\n",
+    "            'Genero': genero,\n",
+    "            'frequencia_aparicao': frequencia_aparicao,\n",
+    "            'streak_anos': streak_anos,\n",
+    "            'anos_desde_ultima': anos_desde_ultima,\n",
+    "            'aparicao_unica': aparicao_unica,\n",
+    "            'anos_desde_unica_aparicao': anos_desde_unica_aparicao,\n",
+    "            'dropout_score': dropout_score,\n",
+    "            'forca_musica': forca_musica,\n",
+    "            'penalidade_one_hit': penalidade_one_hit,\n",
+    "            'volatilidade_posicao': volatilidade_posicao,\n",
+    "            'consistencia': consistencia,\n",
+    "            'posicao_media': posicao_media,\n",
+    "            'melhor_posicao': melhor_posicao,\n",
+    "            'pior_posicao': pior_posicao,\n",
+    "            'ultima_posicao': ultima_posicao,\n",
+    "            'tendencia_posicao': tendencia_posicao,\n",
+    "            'num_aparicoes': len(anos_aparicao),\n",
+    "            'ultimo_ano': ultimo_ano\n",
+    "        })\n",
+    "    \n",
+    "    return pd.DataFrame(features_list)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "622257a7",
+   "metadata": {},
+   "source": [
+    "## 4. Preparação dos dados de treino"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7473753a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Preparando dados de treino...\")\n",
+    "\n",
+    "anos = sorted(df['Ano'].unique())\n",
+    "\n",
+    "dados_treino = []\n",
+    "\n",
+    "for i in range(len(anos) - 1):\n",
+    "    ano_atual = anos[i]\n",
+    "    ano_proximo = anos[i + 1]\n",
+    "    \n",
+    "    # Features até o ano atual\n",
+    "    df_ate_ano = df[df['Ano'] <= ano_atual]\n",
+    "    features_ano = calcular_features_musica(df_ate_ano, ano_proximo)\n",
+    "    \n",
+    "    # Target: posição no próximo ano (ou 501 se não apareceu)\n",
+    "    df_proximo_ano = df[df['Ano'] == ano_proximo]\n",
+    "    \n",
+    "    for _, row in features_ano.iterrows():\n",
+    "        id_musica = row['id_musica']\n",
+    "        \n",
+    "        # Verificar se apareceu no próximo ano\n",
+    "        musica_proximo = df_proximo_ano[df_proximo_ano['id_musica'] == id_musica]\n",
+    "        \n",
+    "        if len(musica_proximo) > 0:\n",
+    "            posicao_proxima = musica_proximo['Posicao'].iloc[0]\n",
+    "            apareceu = 1\n",
+    "        else:\n",
+    "            posicao_proxima = 501  # Não apareceu\n",
+    "            apareceu = 0\n",
+    "        \n",
+    "        dados_treino.append({\n",
+    "            **row.to_dict(),\n",
+    "            'ano_previsao': ano_proximo,\n",
+    "            'posicao_proxima': posicao_proxima,\n",
+    "            'apareceu_proximo': apareceu\n",
+    "        })\n",
+    "    \n",
+    "    df_treino = pd.DataFrame(dados_treino)\n",
+    "\n",
+    "    print(f\"Exemplos de treino: {len(df_treino)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16cc4b8f",
+   "metadata": {},
+   "source": [
+    "## 5. Treinamento do modelo"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eddf47c8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Treinando modelos...\")\n",
+    "\n",
+    "# Features para o modelo\n",
+    "feature_cols = [\n",
+    "    'frequencia_aparicao', 'streak_anos', 'anos_desde_ultima',\n",
+    "    'aparicao_unica', 'anos_desde_unica_aparicao', 'dropout_score',\n",
+    "    'forca_musica', 'penalidade_one_hit', 'volatilidade_posicao',\n",
+    "    'consistencia', 'posicao_media', 'melhor_posicao', \n",
+    "    'ultima_posicao', 'tendencia_posicao', 'num_aparicoes'\n",
+    "]\n",
+    "\n",
+    "X = df_treino[feature_cols].fillna(0)\n",
+    "\n",
+    "# Modelo 1: Prever se vai aparecer (classificação binária)\n",
+    "y_aparece = df_treino['apareceu_proximo']\n",
+    "\n",
+    "# Modelo 2: Prever posição (apenas para músicas que aparecem)\n",
+    "df_apareceu = df_treino[df_treino['apareceu_proximo'] == 1]\n",
+    "X_pos = df_apareceu[feature_cols].fillna(0)\n",
+    "y_pos = df_apareceu['posicao_proxima']\n",
+    "\n",
+    "# Treinar modelos\n",
+    "print(\"Treinando modelo de aparição...\")\n",
+    "modelo_aparicao = GradientBoostingRegressor(n_estimators=200, max_depth=5, random_state=42)\n",
+    "modelo_aparicao.fit(X, y_aparece)\n",
+    "\n",
+    "print(\"Treinando modelo de posição...\")\n",
+    "modelo_posicao = RandomForestRegressor(n_estimators=200, max_depth=15, random_state=42)\n",
+    "modelo_posicao.fit(X_pos, y_pos)\n",
+    "\n",
+    "# Importância das features\n",
+    "print(\"\\nImportância das Features (Aparição):\")\n",
+    "importancias = pd.DataFrame({\n",
+    "    'feature': feature_cols,\n",
+    "    'importancia': modelo_aparicao.feature_importances_\n",
+    "}).sort_values('importancia', ascending=False)\n",
+    "print(importancias.head(10))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e8d44f97",
+   "metadata": {},
+   "source": [
+    "## 6. Geração do ranking"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5f52a882",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# 6. GERAÇÃO DO RANKING PREVISTO\n",
+    "# =============================================================================\n",
+    "print(f\"Gerando ranking previsto para {ano_predicao}...\")\n",
+    "\n",
+    "# Calcular features para todas as músicas\n",
+    "features_atual = calcular_features_musica(df, ano_predicao)\n",
+    "\n",
+    "X = features_atual[feature_cols].fillna(0)\n",
+    "\n",
+    "# Prever probabilidade de aparecer\n",
+    "prob_aparecer = modelo_aparicao.predict(X)\n",
+    "prob_aparecer = np.clip(prob_aparecer, 0, 1)\n",
+    "\n",
+    "# Prever posição\n",
+    "posicao_prevista = modelo_posicao.predict(X)\n",
+    "posicao_prevista = np.clip(posicao_prevista, 1, 500)\n",
+    "\n",
+    "# Combinar resultados\n",
+    "features_atual['prob_aparecer'] = prob_aparecer\n",
+    "features_atual['posicao_prevista'] = posicao_prevista\n",
+    "\n",
+    "# Score combinado: músicas com maior probabilidade e melhor posição\n",
+    "features_atual['score_final'] = (\n",
+    "    features_atual['prob_aparecer'] * 100 - \n",
+    "    features_atual['posicao_prevista'] * 0.1\n",
+    ")\n",
+    "\n",
+    "# Ordenar por score\n",
+    "ranking = features_atual.sort_values('score_final', ascending=False).copy()\n",
+    "\n",
+    "# Adicionar posição no ranking\n",
+    "ranking['posicao_ranking'] = range(1, len(ranking) + 1)\n",
+    "\n",
+    "# Normalizar probabilidades para que somem 100% em cada posição\n",
+    "# (probabilidade de estar exatamente naquela posição)\n",
+    "ranking['prob_posicao_exata'] = ranking['prob_aparecer'] / ranking['prob_aparecer'].sum()\n",
+    "ranking['prob_posicao_exata'] = ranking['prob_posicao_exata'] * 100\n",
+    "\n",
+    "print(\"\\n\" + \"=\" * 80)\n",
+    "print(f\"RANKING PREVISTO PARA {ano_predicao}\")\n",
+    "print(\"=\" * 80)\n",
+    "print(\"\\nTop 20 músicas:\")\n",
+    "print(ranking.head(20).to_string(index=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f6802450",
+   "metadata": {},
+   "source": [
+    "## 7. Visualização"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "68e182ca",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"\\n\" + \"=\" * 80)\n",
+    "print(\"ANÁLISE DOS RESULTADOS\")\n",
+    "print(\"=\" * 80)\n",
+    "\n",
+    "print(f\"\\nTotal de músicas no ranking: {len(ranking)}\")\n",
+    "print(f\"\\nProbabilidade média de aparecer: {ranking['prob_aparecer'].mean():.2%}\")\n",
+    "print(f\"Força média das músicas: {ranking['forca_musica'].mean():.3f}\")\n",
+    "print(f\"Dropout score médio: {ranking['dropout_score'].mean():.3f}\")\n",
+    "\n",
+    "print(\"\\nDistribuição de Streak Anos:\")\n",
+    "print(ranking['streak_anos'].value_counts().sort_index().head(10))\n",
+    "\n",
+    "print(\"\\nMúsicas com maior probabilidade de aparecer:\")\n",
+    "print(ranking.nlargest(10, 'prob_aparecer')[\n",
+    "    ['posicao_ranking', 'Artista', 'Musica', 'prob_aparecer', 'forca_musica']\n",
+    "].to_string(index=False))\n",
+    "\n",
+    "print(\"\\nMúsicas em risco (maior dropout_score):\")\n",
+    "print(ranking.nlargest(10, 'dropout_score')[\n",
+    "    ['posicao_ranking', 'Artista', 'Musica', 'dropout_score', 'streak_anos']\n",
+    "].to_string(index=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c0f219b",
+   "metadata": {},
+   "source": [
+    "## 8. Exportação"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6aeee619",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ranking = ranking[['posicao_ranking', 'Artista', 'Musica', 'Observacao', \n",
+    "                'prob_aparecer', 'prob_posicao_exata', 'posicao_prevista',\n",
+    "                'forca_musica', 'dropout_score', 'streak_anos']]\n",
+    "ranking.to_csv(\"../data/predicao_proximo_ano.csv\", index=False)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/probabilidades_proximo_ano.ipynb

@@ -0,0 +1,598 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1227c753",
+   "metadata": {},
+   "source": [
+    "## 1. Configurações e carregamento do dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bd199811",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings('ignore')\n",
+    "\n",
+    "dataset_file = '../data/500+.csv'\n",
+    "ano_predicao = 2025\n",
+    "\n",
+    "def filtrar_inconsistencias(df_data):\n",
+    "    return df_data.loc[(df_data['Artista'] != '???') & (df_data['Musica'].str.len() > 0) & (df_data['Observacao'] != 'repetida')]\n",
+    "\n",
+    "def load_data(agregar_pinkfloyd):\n",
+    "    df_data = pd.read_csv(dataset_file)\n",
+    "    df_data['Data_Lancamento_Album'] = pd.to_datetime(df_data['Data_Lancamento_Album'])\n",
+    "    df_data['Decada_Musica'] = (df_data['Data_Lancamento_Album'].dt.year // 10) * 10\n",
+    "    df_data['Ano_Musica'] = df_data['Data_Lancamento_Album'].dt.year\n",
+    "    df_data['Duracao'] = df_data.loc[:,'Duracao'].fillna(value=0)\n",
+    "    if (agregar_pinkfloyd):\n",
+    "        df_data.loc[df_data['Musica'].str.contains('Another Brick', na=False), 'Musica'] = 'Another Brick in the Wall'\n",
+    "        df_data.loc[df_data['Musica'].str.contains('Another Brick', na=False), 'Duracao'] = 508\n",
+    "\n",
+    "    df_data = df_data.drop(['Artista_Origem', 'Musica_Origem', 'Artista_Wikidata_ID', 'Artista_Wikidata', 'Artista_Wiki', 'Country', 'Genre', 'Musica_Wikidata_ID', 'Musica_Wikidata', 'Musica_Wiki', 'Album_Single_Wikidata_ID', 'Album_Single_Wikidata', 'Album_Single_Wiki', 'Data_Lancamento_Album'], axis=1)\n",
+    "    df_data.rename(columns={'Album_Single':'Album'}, inplace=True)\n",
+    "    df_data = filtrar_inconsistencias(df_data)\n",
+    "    return df_data\n",
+    "\n",
+    "\n",
+    "df = load_data(True)\n",
+    "df = df[df['Ano'] < ano_predicao]\n",
+    "print(\"Dataset carregado com sucesso!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4f8aed19",
+   "metadata": {},
+   "source": [
+    "## 2. Identificador única da música"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ac64cd77",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Criar identificador único baseado na tríplice Artista-Musica-Observacao\n",
+    "df['Observacao_filled'] = df['Observacao'].fillna('NONE')\n",
+    "df['ID_Musica'] = df['Artista'] + '|||' + df['Musica'] + '|||' + df['Observacao_filled']\n",
+    "\n",
+    "print(f\"\\nTotal de músicas únicas: {df['ID_Musica'].nunique()}\")\n",
+    "print(f\"Total de registros: {len(df)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4075053",
+   "metadata": {},
+   "source": [
+    "## 3. Engenharia de features temporais"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d1346d8b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_sorted = df.sort_values(['ID_Musica', 'Ano'])\n",
+    "features_list = []\n",
+    "\n",
+    "print(\"Criando features históricas...\")\n",
+    "\n",
+    "for musica_id in df['ID_Musica'].unique():\n",
+    "    df_musica = df_sorted[df_sorted['ID_Musica'] == musica_id].copy()\n",
+    "    \n",
+    "    for idx, row in df_musica.iterrows():\n",
+    "        ano_atual = row['Ano']\n",
+    "        historico = df_musica[df_musica['Ano'] < ano_atual]\n",
+    "        \n",
+    "        features = {\n",
+    "            'ID_Musica': musica_id,\n",
+    "            'Ano': ano_atual,\n",
+    "            'Posicao': row['Posicao'],\n",
+    "            'Artista': row['Artista'],\n",
+    "            'Musica': row['Musica'],\n",
+    "            'Pais': row['Pais'],\n",
+    "            'Genero': row['Genero'],\n",
+    "            'Duracao': row['Duracao'],\n",
+    "            'Ano_Musica': row['Ano_Musica'],\n",
+    "            'Decada_Musica': row['Decada_Musica'],\n",
+    "            \n",
+    "            # Features históricas\n",
+    "            'num_aparicoes': len(historico),\n",
+    "            'melhor_posicao': historico['Posicao'].min() if len(historico) > 0 else np.nan,\n",
+    "            'pior_posicao': historico['Posicao'].max() if len(historico) > 0 else np.nan,\n",
+    "            'posicao_media': historico['Posicao'].mean() if len(historico) > 0 else np.nan,\n",
+    "            'posicao_std': historico['Posicao'].std() if len(historico) > 0 else np.nan,\n",
+    "            'anos_desde_primeira': ano_atual - historico['Ano'].min() if len(historico) > 0 else 0,\n",
+    "            'apareceu_ano_anterior': 1 if (ano_atual - 1) in historico['Ano'].values else 0,\n",
+    "            'posicao_ano_anterior': historico[historico['Ano'] == ano_atual - 1]['Posicao'].values[0] \n",
+    "                                    if (ano_atual - 1) in historico['Ano'].values else np.nan,\n",
+    "            'tendencia_posicao': None,  # Calcular depois\n",
+    "            'idade_musica': ano_atual - row['Ano_Musica']\n",
+    "        }\n",
+    "        \n",
+    "        # Calcular tendência (melhoria ou piora nas últimas aparições)\n",
+    "        if len(historico) >= 2:\n",
+    "            ultimas_posicoes = historico.tail(3)['Posicao'].values\n",
+    "            if len(ultimas_posicoes) >= 2:\n",
+    "                features['tendencia_posicao'] = ultimas_posicoes[-1] - ultimas_posicoes[0]\n",
+    "        \n",
+    "        features_list.append(features)\n",
+    "    \n",
+    "df_features = pd.DataFrame(features_list)\n",
+    "print(f\"Features criadas com sucesso! Shape: {df_features.shape}\")\n",
+    "print(f\"\\nColunas disponíveis:\")\n",
+    "print(df_features.columns.tolist())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7cfd2b98",
+   "metadata": {},
+   "source": [
+    "## 4. Engenharia de features de aparição"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "97c3ae18",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Criando features de aparição...\")\n",
+    "\n",
+    "ano_limite = ano_predicao - 1\n",
+    "df_historico = df_features[df_features['Ano'] <= ano_limite].copy()\n",
+    "\n",
+    "# Obter todas as músicas únicas que já apareceram\n",
+    "musicas_unicas = df_historico['ID_Musica'].unique()\n",
+    "\n",
+    "features_atualizadas = []\n",
+    "\n",
+    "for musica_id in musicas_unicas:\n",
+    "    df_musica = df_historico[df_historico['ID_Musica'] == musica_id].sort_values('Ano')\n",
+    "    \n",
+    "    # Pegar informações da última aparição\n",
+    "    ultima_aparicao = df_musica.iloc[-1]\n",
+    "    \n",
+    "    # Calcular features baseadas em TODO o histórico\n",
+    "    features = {\n",
+    "        'ID_Musica': musica_id,\n",
+    "        'Artista': ultima_aparicao['Artista'],\n",
+    "        'Musica': ultima_aparicao['Musica'],\n",
+    "        'Musica': ultima_aparicao['Musica'],\n",
+    "        'Pais': ultima_aparicao['Pais'],\n",
+    "        'Genero': ultima_aparicao['Genero'],\n",
+    "        'Duracao': ultima_aparicao['Duracao'],\n",
+    "        'Ano_Musica': ultima_aparicao['Ano_Musica'],\n",
+    "        'Decada_Musica': ultima_aparicao['Decada_Musica'],\n",
+    "        \n",
+    "        # FEATURES HISTÓRICAS (considerando TUDO até ano_limite)\n",
+    "        'num_aparicoes': len(df_musica),\n",
+    "        'melhor_posicao': df_musica['Posicao'].min(),\n",
+    "        'pior_posicao': df_musica['Posicao'].max(),\n",
+    "        'posicao_media': df_musica['Posicao'].mean(),\n",
+    "        'posicao_std': df_musica['Posicao'].std() if len(df_musica) > 1 else 0,\n",
+    "        'anos_desde_primeira': ano_limite - df_musica['Ano'].min(),\n",
+    "        'apareceu_ano_anterior': 1 if ano_limite in df_musica['Ano'].values else 0,\n",
+    "        'posicao_ano_anterior': df_musica[df_musica['Ano'] == ano_limite]['Posicao'].values[0] \n",
+    "                                if ano_limite in df_musica['Ano'].values else np.nan,\n",
+    "        'Posicao': ultima_aparicao['Posicao'],  # Última posição conhecida\n",
+    "        'idade_musica': ano_limite - ultima_aparicao['Ano_Musica'],\n",
+    "        'anos_desde_ultima': ano_limite - df_musica['Ano'].max(),\n",
+    "        \n",
+    "        # Tendência das últimas 3 aparições\n",
+    "        'tendencia_posicao': 0\n",
+    "    }\n",
+    "    \n",
+    "    # Calcular tendência\n",
+    "    if len(df_musica) >= 2:\n",
+    "        ultimas_posicoes = df_musica.tail(3)['Posicao'].values\n",
+    "        if len(ultimas_posicoes) >= 2:\n",
+    "            features['tendencia_posicao'] = ultimas_posicoes[-1] - ultimas_posicoes[0]\n",
+    "    \n",
+    "    # Calcular frequência de aparição (% anos que apareceu)\n",
+    "    anos_possiveis = ano_limite - df_musica['Ano'].min() + 1\n",
+    "    features['frequencia_aparicao'] = len(df_musica) / anos_possiveis if anos_possiveis > 0 else 0\n",
+    "    \n",
+    "    # Verificar se está em \"streak\" (apareceu nos últimos N anos consecutivos)\n",
+    "    streak = 0\n",
+    "    for ano_check in range(ano_limite, ano_limite - 5, -1):\n",
+    "        if ano_check in df_musica['Ano'].values:\n",
+    "            streak += 1\n",
+    "        else:\n",
+    "            break\n",
+    "    features['streak_anos'] = streak\n",
+    "    \n",
+    "    # ===== NOVAS FEATURES PARA TRATAR OUTLIERS =====\n",
+    "    \n",
+    "    # Flag: música apareceu apenas 1 vez?\n",
+    "    features['aparicao_unica'] = 1 if len(df_musica) == 1 else 0\n",
+    "    \n",
+    "    # Se apareceu apenas 1 vez, há quantos anos foi?\n",
+    "    features['anos_desde_unica_aparicao'] = ano_limite - df_musica['Ano'].max() if len(df_musica) == 1 else 0\n",
+    "    \n",
+    "    # Taxa de \"dropout\" - chance de nunca mais voltar após primeira aparição\n",
+    "    # Músicas que aparecem 1x e nunca voltam têm alta taxa de dropout\n",
+    "    if len(df_musica) == 1:\n",
+    "        anos_decorridos = ano_limite - df_musica['Ano'].max()\n",
+    "        # Se passou 1 ano: dropout_score = 1, 2 anos = 2, etc\n",
+    "        features['dropout_score'] = anos_decorridos\n",
+    "    else:\n",
+    "        features['dropout_score'] = 0\n",
+    "    \n",
+    "    # Consistência: razão entre aparições e anos possíveis\n",
+    "    # Valores baixos indicam aparições esporádicas\n",
+    "    features['consistencia'] = features['frequencia_aparicao']\n",
+    "    \n",
+    "    # Volatilidade de posição (amplitude)\n",
+    "    if len(df_musica) > 1:\n",
+    "        features['volatilidade_posicao'] = features['pior_posicao'] - features['melhor_posicao']\n",
+    "    else:\n",
+    "        features['volatilidade_posicao'] = 0\n",
+    "    \n",
+    "    # Força da música: combinação de múltiplos fatores\n",
+    "    # Quanto maior, mais \"estabelecida\" é a música\n",
+    "    forca = 0\n",
+    "    if len(df_musica) >= 3:\n",
+    "        forca += 3  # Apareceu múltiplas vezes\n",
+    "    if features['frequencia_aparicao'] > 0.5:\n",
+    "        forca += 2  # Alta frequência\n",
+    "    if features['streak_anos'] >= 2:\n",
+    "        forca += 2  # Em streak\n",
+    "    if features['melhor_posicao'] <= 100:\n",
+    "        forca += 1  # Já esteve no top 100\n",
+    "    \n",
+    "    features['forca_musica'] = forca\n",
+    "    \n",
+    "    # Penalidade para \"one-hit wonders\" (músicas que aparecem 1x e param)\n",
+    "    # Quanto maior o tempo desde a única aparição, maior a penalidade\n",
+    "    if features['aparicao_unica'] == 1:\n",
+    "        features['penalidade_one_hit'] = min(5, features['anos_desde_unica_aparicao'])\n",
+    "    else:\n",
+    "        features['penalidade_one_hit'] = 0\n",
+    "    \n",
+    "    features_atualizadas.append(features)\n",
+    "\n",
+    "features_atualizadas = pd.DataFrame(features_atualizadas)\n",
+    "\n",
+    "print(f\"Features criadas com sucesso! Shape: {features_atualizadas.shape}\")\n",
+    "print(f\"\\nColunas disponíveis:\")\n",
+    "print(features_atualizadas.columns.tolist())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "afc71e92",
+   "metadata": {},
+   "source": [
+    "## 5. Probabilidade de aparição a cada ano"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1d62500b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"Calculando probabilidades de aparição...\")\n",
+    "\n",
+    "# Preparar dados para cada música em cada ano\n",
+    "resultados = []\n",
+    "\n",
+    "for musica_id in df_features['ID_Musica'].unique():\n",
+    "    df_musica = df_features[df_features['ID_Musica'] == musica_id].sort_values('Ano')\n",
+    "    \n",
+    "    for i in range(len(df_musica) - 1):\n",
+    "        ano_atual = df_musica.iloc[i]['Ano']\n",
+    "        ano_seguinte = ano_atual + 1\n",
+    "        apareceu_seguinte = 1 if ano_seguinte in df_musica['Ano'].values else 0\n",
+    "        \n",
+    "        resultado = df_musica.iloc[i].to_dict()\n",
+    "        resultado['apareceu_proximo_ano'] = apareceu_seguinte\n",
+    "        resultados.append(resultado)\n",
+    "\n",
+    "\n",
+    "df_prob = pd.DataFrame(resultados)\n",
+    "\n",
+    "# Estatísticas gerais\n",
+    "taxa_aparicao_geral = df_prob['apareceu_proximo_ano'].mean()\n",
+    "print(f\"\\nTaxa geral de aparição no próximo ano: {taxa_aparicao_geral:.2%}\")\n",
+    "\n",
+    "# Análise por número de aparições\n",
+    "print(\"\\nTaxa de aparição por histórico:\")\n",
+    "for n in range(1, 6):\n",
+    "    mask = df_prob['num_aparicoes'] == n\n",
+    "    if mask.sum() > 0:\n",
+    "        taxa = df_prob[mask]['apareceu_proximo_ano'].mean()\n",
+    "        print(f\"  {n} aparições anteriores: {taxa:.2%} (n={mask.sum()})\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cdab325b",
+   "metadata": {},
+   "source": [
+    "## 6. Modelo para cálculo de probabilidade de aparição"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c96cd20b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Selecionar features numéricas\n",
+    "feature_cols_aparicao = ['num_aparicoes', 'melhor_posicao', 'pior_posicao', \n",
+    "                'posicao_media', 'anos_desde_primeira', 'apareceu_ano_anterior',\n",
+    "                'Duracao', 'idade_musica', 'Posicao']\n",
+    "\n",
+    "# Preparar dados\n",
+    "df_train = df_prob[df_prob['Ano'] < ano_predicao - 2].copy()\n",
+    "df_test = df_prob[df_prob['Ano'] >= ano_predicao - 2].copy()\n",
+    "\n",
+    "# Remover NaNs\n",
+    "df_train = df_train.dropna(subset=feature_cols_aparicao + ['apareceu_proximo_ano'])\n",
+    "df_test = df_test.dropna(subset=feature_cols_aparicao)\n",
+    "\n",
+    "X_train = df_train[feature_cols_aparicao]\n",
+    "y_train = df_train['apareceu_proximo_ano']\n",
+    "X_test = df_test[feature_cols_aparicao]\n",
+    "\n",
+    "# Treinar modelo\n",
+    "modelo_aparicao = RandomForestClassifier(n_estimators=100, max_depth=10, random_state=42)\n",
+    "modelo_aparicao.fit(X_train, y_train)\n",
+    "\n",
+    "# Importância das features\n",
+    "feature_importance = pd.DataFrame({\n",
+    "    'feature': feature_cols_aparicao,\n",
+    "    'importance': modelo_aparicao.feature_importances_\n",
+    "}).sort_values('importance', ascending=False)\n",
+    "\n",
+    "print(\"\\nImportância das features para aparição:\")\n",
+    "print(feature_importance.to_string(index=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37aa65f2",
+   "metadata": {},
+   "source": [
+    "## 7. Geração de probabilidades de aparição"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "45c8b7aa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(f\"{'='*80}\")\n",
+    "print(f\"CALCULANDO PREDIÇÕES PARA {ano_predicao}\")\n",
+    "print(f\"Considerando TODO o histórico até {ano_predicao - 1}\")\n",
+    "print(f\"{'='*80}\")\n",
+    "\n",
+    "# Recalcular features baseado em todo histórico até o ano anterior\n",
+    "df_atual = features_atualizadas\n",
+    "\n",
+    "print(f\"\\nTotal de músicas no histórico: {len(df_atual)}\")\n",
+    "print(f\"Músicas que apareceram em {ano_predicao - 1}: {df_atual['apareceu_ano_anterior'].sum()}\")\n",
+    "print(f\"Músicas com apenas 1 aparição: {df_atual['aparicao_unica'].sum()}\")\n",
+    "\n",
+    "predicoes = []\n",
+    "\n",
+    "for _, row in df_atual.iterrows():\n",
+    "    try:\n",
+    "        # Preparar features para aparição (incluindo as novas)\n",
+    "        features_disponiveis = [f for f in feature_cols_aparicao if f in row.index]\n",
+    "        X_aparicao = row[features_disponiveis].values.reshape(1, -1)\n",
+    "        X_aparicao = np.nan_to_num(X_aparicao, nan=0)\n",
+    "        \n",
+    "        # Prever probabilidade de aparição\n",
+    "        prob_aparicao_raw = modelo_aparicao.predict_proba(X_aparicao)[0][1]\n",
+    "        \n",
+    "        # ===== APLICAR AJUSTES PARA OUTLIERS =====\n",
+    "        prob_aparicao = prob_aparicao_raw\n",
+    "        \n",
+    "        # REGRA 1: Penalizar músicas com apenas 1 aparição\n",
+    "        if row['aparicao_unica'] == 1:\n",
+    "            anos_desde = row['anos_desde_unica_aparicao']\n",
+    "            \n",
+    "            # Penalidade crescente: 1 ano = 20%, 2 anos = 40%, 3+ anos = 60%\n",
+    "            if anos_desde == 0:  # Apareceu no ano anterior\n",
+    "                penalidade = 0.20\n",
+    "            elif anos_desde == 1:\n",
+    "                penalidade = 0.40\n",
+    "            elif anos_desde == 2:\n",
+    "                penalidade = 0.55\n",
+    "            else:\n",
+    "                penalidade = 0.70\n",
+    "            \n",
+    "            prob_aparicao *= (1 - penalidade)\n",
+    "        \n",
+    "        # REGRA 2: Bonus para músicas consistentes (múltiplas aparições)\n",
+    "        if row['num_aparicoes'] >= 3 and row['frequencia_aparicao'] > 0.5:\n",
+    "            bonus = min(0.15, row['frequencia_aparicao'] * 0.2)\n",
+    "            prob_aparicao = min(0.99, prob_aparicao * (1 + bonus))\n",
+    "        \n",
+    "        # REGRA 3: Penalizar músicas que não aparecem há muito tempo\n",
+    "        if row['anos_desde_ultima'] >= 3:\n",
+    "            penalidade_ausencia = min(0.50, row['anos_desde_ultima'] * 0.10)\n",
+    "            prob_aparicao *= (1 - penalidade_ausencia)\n",
+    "        \n",
+    "        # REGRA 4: Bonus para streak (apareceu nos últimos anos consecutivos)\n",
+    "        if row['streak_anos'] >= 2:\n",
+    "            bonus_streak = min(0.20, row['streak_anos'] * 0.05)\n",
+    "            prob_aparicao = min(0.99, prob_aparicao * (1 + bonus_streak))\n",
+    "        \n",
+    "        # REGRA 5: Ajuste baseado na força geral da música\n",
+    "        if row['forca_musica'] >= 5:\n",
+    "            prob_aparicao = min(0.99, prob_aparicao * 1.10)\n",
+    "        elif row['forca_musica'] == 0 and row['aparicao_unica'] == 1:\n",
+    "            prob_aparicao *= 0.5  # Penalidade severa para one-hits fracos\n",
+    "        \n",
+    "        predicao = {\n",
+    "            'ID_Musica': row['ID_Musica'],\n",
+    "            'Artista': row['Artista'],\n",
+    "            'Musica': row['Musica'],\n",
+    "            'Genero': row['Genero'],\n",
+    "            'Pais': row['Pais'],\n",
+    "            'prob_aparicao_raw': prob_aparicao_raw,  # Probabilidade antes dos ajustes\n",
+    "            'prob_aparicao': prob_aparicao,  # Probabilidade ajustada\n",
+    "            'num_aparicoes_historicas': row['num_aparicoes'],\n",
+    "            'apareceu_ano_anterior': row['apareceu_ano_anterior'],\n",
+    "            'frequencia_aparicao': row['frequencia_aparicao'],\n",
+    "            'streak_anos': row['streak_anos'],\n",
+    "            'anos_desde_primeira': row['anos_desde_primeira'],\n",
+    "            'aparicao_unica': row['aparicao_unica'],\n",
+    "            'forca_musica': row['forca_musica'],\n",
+    "            'anos_desde_ultima': row['anos_desde_ultima']\n",
+    "        }\n",
+    "        \n",
+    "        predicoes.append(predicao)\n",
+    "        \n",
+    "    except Exception as e:\n",
+    "        print(f\"Erro ao processar música {row['ID_Musica']}: {e}\")\n",
+    "        continue\n",
+    "\n",
+    "df_predicoes = pd.DataFrame(predicoes)\n",
+    "df_predicoes = df_predicoes.sort_values('prob_aparicao', ascending=False)\n",
+    "\n",
+    "\n",
+    "print(f\"\\nTotal de músicas analisadas: {len(df_predicoes)}\")\n",
+    "print(f\"Músicas com probabilidade > 50%: {(df_predicoes['prob_aparicao'] > 0.5).sum()}\")\n",
+    "print(f\"Músicas com probabilidade > 70%: {(df_predicoes['prob_aparicao'] > 0.7).sum()}\")\n",
+    "print(f\"Músicas com probabilidade > 90%: {(df_predicoes['prob_aparicao'] > 0.9).sum()}\")\n",
+    "\n",
+    "# Análise de one-hit wonders\n",
+    "one_hits = df_predicoes[df_predicoes['aparicao_unica'] == 1]\n",
+    "print(f\"\\n{'='*80}\")\n",
+    "print(f\"ANÁLISE DE ONE-HIT WONDERS (músicas com apenas 1 aparição)\")\n",
+    "print(f\"{'='*80}\")\n",
+    "print(f\"Total de one-hits: {len(one_hits)}\")\n",
+    "print(f\"Probabilidade média (one-hits): {one_hits['prob_aparicao'].mean():.2%}\")\n",
+    "print(f\"Probabilidade média (múltiplas aparições): {df_predicoes[df_predicoes['aparicao_unica'] == 0]['prob_aparicao'].mean():.2%}\")\n",
+    "print(f\"\\nOne-hits com maior probabilidade (top 10):\")\n",
+    "print(one_hits.head(10)[['Artista', 'prob_aparicao_raw', 'prob_aparicao', \n",
+    "                          'anos_desde_ultima', 'forca_musica']].to_string(index=False))\n",
+    "\n",
+    "print(f\"\\n{'='*80}\")\n",
+    "print(f\"Top 20 músicas com MAIOR probabilidade de aparecer em {ano_predicao}:\")\n",
+    "print(f\"{'='*80}\")\n",
+    "print(df_predicoes.head(20)[['Artista', 'Genero', 'prob_aparicao', \n",
+    "                                   'num_aparicoes_historicas', 'streak_anos', \n",
+    "                                   'apareceu_ano_anterior', 'aparicao_unica']].to_string(index=False))\n",
+    "\n",
+    "# Criar visualização comparativa\n",
+    "print(\"\\n{'='*80}\")\n",
+    "print(\"Comparando probabilidades RAW vs AJUSTADAS\")\n",
+    "print(\"{'='*80}\")\n",
+    "\n",
+    "# Comparar diferenças para one-hits\n",
+    "one_hits_sorted = one_hits.copy()\n",
+    "one_hits_sorted['diferenca'] = one_hits_sorted['prob_aparicao_raw'] - one_hits_sorted['prob_aparicao']\n",
+    "one_hits_sorted = one_hits_sorted.sort_values('diferenca', ascending=False)\n",
+    "\n",
+    "print(\"\\nOne-hits com MAIOR ajuste (penalidade):\")\n",
+    "print(one_hits_sorted.head(10)[['Artista', 'prob_aparicao_raw', 'prob_aparicao', \n",
+    "                                 'diferenca', 'anos_desde_ultima']].to_string(index=False))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "886e7408",
+   "metadata": {},
+   "source": [
+    "## 8. Visualização"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6c8f167b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# ============================================================================\n",
+    "# 8. VISUALIZAÇÕES\n",
+    "# ============================================================================\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(20, 5))\n",
+    "\n",
+    "# 1. Distribuição de probabilidades\n",
+    "axes[0].hist(df_predicoes['prob_aparicao'], bins=30, edgecolor='black')\n",
+    "axes[0].set_xlabel('Probabilidade de Aparição')\n",
+    "axes[0].set_ylabel('Número de Músicas')\n",
+    "axes[0].set_title('Distribuição de Probabilidades de Aparição')\n",
+    "axes[0].axvline(0.5, color='red', linestyle='--', label='Threshold')\n",
+    "axes[0].legend()\n",
+    "\n",
+    "# 2. Relação entre número de aparições e probabilidade\n",
+    "df_prob_agg = df_prob.groupby('num_aparicoes')['apareceu_proximo_ano'].mean()\n",
+    "axes[1].plot(df_prob_agg.index, df_prob_agg.values, marker='o')\n",
+    "axes[1].set_xlabel('Número de Aparições Anteriores')\n",
+    "axes[1].set_ylabel('Taxa de Aparição no Próximo Ano')\n",
+    "axes[1].set_title('Histórico vs Probabilidade de Aparição')\n",
+    "axes[1].grid(True, alpha=0.3)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fa37c886",
+   "metadata": {},
+   "source": [
+    "## 9. Exportação"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "802d426a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_predicoes.to_csv(\"../data/prob_proximo_ano.csv\", index=False)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

notebooks/wikpedia_scrapping.ipynb

@@ -0,0 +1 @@
+{"cells":[{"cell_type":"code","execution_count":null,"metadata":{"id":"jU_xnJo3rdIm"},"outputs":[],"source":["!pip install requests\n","!pip install beautifulsoup4"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"hotCo9ljroa4"},"outputs":[],"source":["import pandas as pd\n","import requests\n","from bs4 import BeautifulSoup\n","\n","df = pd.read_csv(\"./data/500+.csv\")\n","df['Duracao'] = '0:00'\n","\n","lista = df.drop_duplicates(subset='Musica_Wiki').Musica_Wiki.to_list()\n","\n","for musica in lista:\n","\t\ttry:\n","\t\t\tresponse = requests.get(url=musica)\n","\t\t\tsoup = BeautifulSoup(response.content, 'html.parser')\n","\t\t\tduracao = soup.select('.duration')[0].get_text()\n","\t\t\tprint(musica, duracao)\n","\t\t\tdf.loc[df['Musica_Wiki'] == musica, 'Duracao'] = duracao\n","\t\texcept:\n","\t\t\tdf.loc[df['Musica_Wiki'] == musica, 'Duracao'] = 'erro'\n","\n","df.to_csv('file.csv')"]}],"metadata":{"colab":{"authorship_tag":"ABX9TyOPbFXvcVqRkpw+WntjKwA8","provenance":[]},"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},"nbformat":4,"nbformat_minor":0}

packages.txt

@@ -0,0 +1,2 @@
+locales-all
+ffmpeg

requirements.txt

@@ -1,3 +1,7 @@
-altair
-pandas
-streamlit
+pandas<=1.5.3
+numpy<=1.25.2
+plotly<=6.0.1
+ipython<=7.34.0
+streamlit
+git+https://github.com/hukuhuku-matsuo/streamlit-timeline.git@main
+git+https://github.com/dexplo/bar_chart_race.git@master

resources/style.css

@@ -0,0 +1,143 @@
+html {
+  --black:	#21252a;
+  --grey-1: #343A40;
+  --grey-2: #495057;
+  --grey-3: #868E96;
+  --grey-4: #ADB5BD;
+  --grey-5: #CED4DA;
+  --grey-6: #DEE2E6;
+  --grey-7: #E9ECEF;
+  --grey-8: #F1F3F5;
+  --grey-9: #F8F9FA;
+  --trans-black: rgba(33, 37, 42, .9);
+  --red: #e10600;
+  --gold: #ffda65;
+  --gold-dark: #a3862c;
+  --bronze: #c99355;
+  --bronze-dark: #80582c;
+}
+
+html {
+  box-sizing: border-box;
+}
+
+*, *:before, *:after {
+  box-sizing: inherit;
+}
+
+html, body {
+  width: 100%;
+  height: 100%;
+}
+
+body {
+  font-family: "Inter UI", system-ui;
+  color: var(--black);
+}
+
+.list {
+  width: 100%;
+  max-width: 600px;
+  margin: 3rem auto 3rem;
+  border-radius: 0.4rem;
+  box-shadow: 0px 12px 25px rgba(0, 0, 0, 0.1), 0px 5px 12px rgba(0, 0, 0, 0.07);
+}
+@media screen and (max-width: 800px) {
+  .list {
+    margin: 0 auto;
+  }
+}
+.list__table {
+  width: 100%;
+  border-spacing: 0;
+}
+.list__header {
+  padding: 3rem 2rem;
+  background: white;
+  border-top-left-radius: 0.4rem;
+  border-top-right-radius: 0.4rem;
+}
+.list__header h1, .list__header h5 {
+  margin: 0;
+  padding: 0;
+}
+.list__header h5 {
+  margin-bottom: 0.5rem;
+  text-transform: uppercase;
+  color: var(--red);
+}
+.list__value {
+  display: block;
+  font-size: 18px;
+}
+.list__label {
+  font-size: 11px;
+  opacity: 0.6;
+}
+.list__row {
+  background: var(--grey-7);
+  cursor: pointer;
+  transition: all 300ms ease;
+}
+.list__row:hover, .list__row:focus {
+  transform: scale(1.05);
+  box-shadow: 0px 15px 28px rgba(0, 0, 0, 0.1), 0px 5px 12px rgba(0, 0, 0, 0.08);
+  transition: all 300ms ease;
+}
+.list__row:not(:last-of-type) .list__cell {
+  box-shadow: 0px 2px 0px rgba(0, 0, 0, 0.08);
+}
+.list__row:first-of-type {
+  color: var(--gold-dark);
+  background: var(--grey-9);
+}
+.list__row:first-of-type .list__cell:first-of-type {
+  background: var(--gold);
+  color: var(--gold-dark);
+}
+.list__row:nth-of-type(2) {
+  color: var(--grey-2);
+  background: var(--grey-9);
+}
+.list__row:nth-of-type(2) .list__cell:first-of-type {
+  background: var(--grey-4);
+  color: var(--grey-2);
+}
+.list__row:nth-of-type(3) {
+  color: var(--bronze-dark);
+  background: var(--grey-9);
+}
+.list__row:nth-of-type(3) .list__cell:first-of-type {
+  background: var(--bronze);
+  color: var(--bronze-dark);
+}
+.list__cell {
+  padding: 1rem;
+}
+.list__cell:first-of-type {
+  text-align: center;
+  padding: 1rem 0.2rem;
+  background: var(--grey-5);
+}
+
+.list__icon__red {
+  color:red !important;
+}
+
+.list__icon__green {
+  color:green !important;
+}
+
+.list__icon__grey {
+  color:grey !important;
+}
+
+@keyframes fade {
+  from {
+    opacity: 0;
+  }
+  to {
+    opacity: 1;
+    left: 0;
+  }
+}