1. PREPARAÇÃO DO AMBIENTE

ℹ️ Clique para ver os detalhes

requirements.txt

São as bibliotecas Python que o projeto vai usar.

db-dtypes               # Tipos de dados extras usados pelo BigQuery no pandas (DATE, TIME, STRUCT etc.)
google-auth             # Autenticação e credenciais para acessar APIs e serviços Google
google-cloud-bigquery   # Cliente oficial Python para consultar e manipular dados no BigQuery
igmapper                # Biblioteca para mapeamento/geolocalização e visualização de dados geográficos
ipykernel               # Kernel do Python para execução em notebooks Jupyter
pandas-gbq              # Integração entre pandas e BigQuery para ler/escrever tabelas facilmente
pandas                  # Manipulação e análise de dados em DataFrames
selenium                # Automação de navegador para scraping e testes web
tmdbsimple              # Cliente Python simples para consumir a API do The Movie Database (TMDB)

Ativar ambiente virtual (venv)

O que é? É um ambiente virtual do Python que cria um espaço isolado para instalar bibliotecas de um projeto sem afetar os outros projetos ou o Python do sistema.

Linux/macOS

1. Cria um ambiente virtual Python na pasta .venv

   python3.14 -m venv .venv

2. Ativa o ambiente virtual

   source .venv/bin/activate

3. Atualiza o pip para a versão mais recente

   pip install --upgrade pip

4. Instala todas as dependências do projeto

   pip install -r requirements.txt

Windows (PowerShell)

1. Cria um ambiente virtual Python na pasta .venv

   python -m venv .venv

2. Permite executar scripts locais no PowerShell

   Set-ExecutionPolicy RemoteSigned -Scope CurrentUser

3. Ativa o ambiente virtual no PowerShell

   .venv\Scripts\Activate.ps1

4. Instala todas as dependências do projeto

   python -m pip install -r requirements.txt

[!NOTE] Instalação separada (sem usar requirements.txt)

pip install db-dtypes google-auth google-cloud-bigquery igmapper ipykernel pandas-gbq pandas selenium tmdbsimple

[!WARNING] Erro ModuleNotFoundError → Dependência não instalada no ambiente virtual.

------------------------------------------------------------
ModuleNotFoundError        Traceback (most recent call last)
Cell In[1], line 1
----> 1 import BIBLIOTECA_X

ModuleNotFoundError: No module named 'BIBLIOTECA_X'

Resolva:

pip install BIBLIOTECA_X

[!TIP] Limpar tudo do Ambiente Virtual

Limpar Cache do PIP

pip cache purge

Desinstalar tudo que já foi instalado no VENV

# Linux
pip freeze > req_installed.txt && pip uninstall -r req_installed.txt -y && pip cache purge

# Windows (PowerShell)
pip freeze > req_installed.txt; pip uninstall -r req_installed.txt -y; pip cache purge

VSCode Extensions

• Black Formatter (Microsoft)
• Jupyter (Microsoft)
• Python (Microsoft)
• Pylance (Microsoft)
• Pylint (Microsoft)

2. CONFIGURAÇÃO DO BIGQUERY

ℹ️ Clique para ver os detalhes

1. Criar Projeto no GCP

• https://console.cloud.google.com

Criar a Service Account

Cria uma conta de serviço para autenticar o acesso ao BigQuery.

Adicionar os papéis:

• BigQuery Data Editor → Acesso para editar todos os tipos de conteúdo de conjuntos de dados
• BigQuery Job User → Acesso para executar jobs

Baixar chave:

3. CÓDIGO · Ingestão

ℹ️ Clique para ver os detalhes

1. Import e definição das view com pandas

   from google.cloud import bigquery
   from google.oauth2 import service_account
   import pandas as pd
   
   pd.set_option("display.max_columns", None)
   pd.set_option("display.max_rows", 10)

2. Definição das variáveis utilizadas para ingestão de dados

   dataset_movies_url = "https://media.githubusercontent.com/media/lucas-aulas/dataset-movies/refs/heads/main"
   
   gcp_project_id_aula = "project202605-496913"
   
   gcp_service_acc_file_aluno = "../secrets/____________________.json"
   gcp_id_do_projeto = "____________________"
   my_gcp_cred = service_account.Credentials.from_service_account_file(gcp_service_acc_file_aluno)
   my_gcp_client = bigquery.Client(credentials=my_gcp_cred)

3. Leitura dos dados da fonte externa - GitHub

   df_imdb_filmes = pd.read_csv(f"{dataset_movies_url}/imdb_filmes.csv")

4. Leitura dos dados da fonte externa - BigQuery

   df_boxoffice_dc_marvel = my_gcp_client.query(
       f"SELECT * FROM raw.boxoffice_dc_marvel"
   ).to_dataframe(create_bqstorage_client=False)

5. Ordenando as coluas alfabeticamente

   df_boxoffice_dc_marvel = df_boxoffice_dc_marvel[sorted(df_boxoffice_dc_marvel.columns)]
   df_imdb_filmes = df_imdb_filmes[sorted(df_imdb_filmes.columns)]

6. Envio para o seu banco de dados

   df_imdb_filmes.to_gbq(
       project_id=gcp_id_do_projeto,
       destination_table="bronze.imdb_filmes",
       if_exists="replace",
       credentials=my_gcp_cred,
   )
   
   df_boxoffice_dc_marvel.to_gbq(
       project_id=gcp_id_do_projeto,
       destination_table="bronze.boxoffice_dc_marvel",
       if_exists="replace",
       credentials=my_gcp_cred,
   )

4. CÓDIGO · Tratamento

ℹ️ Clique para ver os detalhes

1. Bibliotecas que vão ser utilizadas

   from google.cloud import bigquery
   from google.oauth2 import service_account
   import pandas as pd
   
   pd.set_option("display.max_columns", None)
   pd.set_option("display.max_rows", 10)

2. Variáveis e informações para a ingestão

   gcp_service_acc_file_aluno = "../secrets/____________________.json"
   gcp_id_do_projeto = "____________________"
   my_gcp_cred = service_account.Credentials.from_service_account_file(gcp_service_acc_file_aluno)
   my_gcp_client = bigquery.Client(credentials=my_gcp_cred)

3. Leitura da tabela boxoffice_dc_marvel no BigQuery

   df_boxoffice_dc_marvel = my_gcp_client.query(
       "SELECT * FROM bronze.boxoffice_dc_marvel"
   ).to_dataframe(create_bqstorage_client=False)

4. Leitura da tabela imdb_filmes no BigQuery

   df_imdb_filmes = my_gcp_client.query(
       "SELECT * FROM bronze.imdb_filmes"
   ).to_dataframe(create_bqstorage_client=False)

5. Merge dos DataFrames

   df_complete_movie_info = (
       pd.merge(
           df_boxoffice_dc_marvel,
           df_imdb_filmes,
           left_on=["FILM", "YEAR"],
           right_on=["TITLE", "YEAR"],
           how="outer"
       )
       .sort_values(by="YEAR", ascending=False)
       .drop_duplicates(keep="last")
   )

6. Filtrando apenas filmes da Marvel e DC

   df_complete_dc_marvel = df_complete_movie_info[
       (df_complete_movie_info["FRANCHISE"] == "Marvel") |
       (df_complete_movie_info["FRANCHISE"] == "DC")
   ]

7. Removendo colunas desnecessárias

   df_complete_dc_marvel = df_complete_dc_marvel.drop(
       columns=[
           "25X_PROD",
           "BOX_OFFICE_GROSS_DOMESTIC_US_AND_CANADA",
           "BOX_OFFICE_GROSS_WORLDWIDE",
           "BUDGET_y",
           "DURATION",
           "LENGTH",
           "MPAA_RATING",
           "TITLE",
           "YEAR",
       ]
   ).reset_index(drop=True)

8. Visualizando os filmes com maior nota IMDB

   df_complete_dc_marvel.sort_values(by="RATING_IMDB", ascending=False).head(2)

9. Tratamento das colunas monetárias, percentuais, datas e inteiros

   df_tratado = df_complete_dc_marvel.copy()

   money_cols = [
       "BOX_OFFICE_GROSS_OTHER_TERRITORIES",
       "BUDGET_x",
       "INFLATION_ADJUSTED_BUDGET",
       "INFLATION_ADJUSTED_WORLDWIDE_GROSS",
       "GROSS_OPENING_WEEKEND",
       "GROSS_US_CANADA",
       "GROSS_WORLD_WIDE",
   ]
   
   for col in money_cols:
       df_tratado[col] = (
           df_tratado[col].astype(str).str.replace("$", "").str.replace(",", "").replace("None", 0).astype(float)
       )

   percent_cols = ["DOMESTIC"]
   
   for col in percent_cols:
       df_tratado[col] = (
           df_tratado[col].astype(str).str.replace("%", "").astype(float)
       )

   date_cols = ["US_RELEASE_DATE"]
   
   for col in date_cols:
       df_tratado[col] = pd.to_datetime(
           df_tratado[col], format="%d/%m/%Y"
       )

   int_cols = [
       "VOTE",
       "WIN",
       "OSCAR",
       "NOMINATION",
       "ROTTEN_TOMATOES_CRITIC_SCORE"
   ]
   
   for col in int_cols:
       df_tratado[col] = (
           df_tratado[col].fillna(0).astype(int)
       )

10. Criando a coluna de ano baseada na data de lançamento

    df_tratado["YEAR"] = (
        df_tratado["US_RELEASE_DATE"].dt.year
    )

11. Padronizando colunas categóricas

    df_tratado["GENRE"] = (
        df_tratado["GENRE"].str.split(",").str[0].str.strip()
    )
    
    df_tratado["COUNTRY_ORIGIN"] = (
        df_tratado["COUNTRY_ORIGIN"].str.split(",").str[0].str.strip()
    )
    
    df_tratado["LANGUAGE"] = (
        df_tratado["LANGUAGE"].str.split(",").str[0].str.strip()
    )
    
    df_tratado["PRODUCTION_COMPANY"] = (
        df_tratado["PRODUCTION_COMPANY"].str.split(",").str[0].str.strip()
    )

12. Organização final das colunas

    df_tratado = df_tratado.drop(
        columns=["Unnamed: 0"], errors="ignore"
    )
    
    df_tratado = df_tratado[
        sorted(df_tratado.columns)
    ]

13. Salvando a tabela tratada na camada Silver

    df_tratado.to_gbq(
        project_id=gcp_id_do_projeto,
        destination_table="silver.complete_dc_marvel",
        if_exists="replace",
        credentials=my_gcp_cred,
    )

5. CÓDIGO · Star Schema

ℹ️ Clique para ver os detalhes

1. Importação das bibliotecas necessárias para conexão com o BigQuery e manipulação dos dados com Pandas.

   from google.cloud import bigquery
   from google.oauth2 import service_account
   import pandas as pd
   
   pd.set_option("display.max_columns", None)
   pd.set_option("display.max_rows", 10)

2. Configuração das credenciais e criação do cliente de conexão com o Google BigQuery.

   gcp_service_acc_file_aluno = "../secrets/meu-projeto-eng-dados-c278f0daa3bf.json"
   gcp_id_do_projeto = "meu-projeto-eng-dados"
   my_gcp_cred = service_account.Credentials.from_service_account_file(gcp_service_acc_file_aluno)
   my_gcp_client = bigquery.Client(credentials=my_gcp_cred)

3. Leitura da tabela Silver armazenada no BigQuery para criação da camada Gold.

   df_silver = my_gcp_client.query(
       f"SELECT * FROM silver.complete_dc_marvel",
   ).to_dataframe(create_bqstorage_client=False)

4. Criação da dimensão de filmes contendo atributos descritivos de cada produção.

   dim_film = (
       df_silver[["FILM", "GENRE", "RATING_MPA", "LANGUAGE", "BREAK_EVEN", "MCU", "MALE_FEMALE_LED", "PHASE"]]
       .drop_duplicates()
       .sort_values(by="FILM")
       .reset_index(drop=True)
   )
   
   dim_film["ID_FILM"] = dim_film.index + 1
   
   dim_film.head(5)

5. Criação da dimensão de equipe técnica contendo diretor, roteirista e ator principal.

   dim_staff = (
       df_silver[["DIRECTOR", "WRITER", "STAR"]]
       .drop_duplicates()
       .sort_values(by=["DIRECTOR", "WRITER"])
       .reset_index(drop=True)
   )
   
   dim_staff["ID_STAFF"] = dim_staff.index + 1
   
   dim_staff.head(2)

6. Criação da dimensão de franquias e famílias de personagens dos filmes.

   dim_franchise = (
       df_silver[["FRANCHISE", "CHARACTER_FAMILY"]]
       .drop_duplicates()
       .sort_values(by=["FRANCHISE", "CHARACTER_FAMILY"])
       .reset_index(drop=True)
   )
   
   dim_franchise["ID_FRANCHISE"] = dim_franchise.index + 1
   
   dim_franchise.head(2)

7. Criação da dimensão de produção contendo empresa produtora, distribuidora e localização das filmagens.

   dim_production = (
       df_silver[["PRODUCTION_COMPANY", "DISTRIBUTOR", "COUNTRY_ORIGIN", "FILMING_LOCATION"]]
       .drop_duplicates()
       .sort_values(by=["PRODUCTION_COMPANY", "DISTRIBUTOR", "COUNTRY_ORIGIN", "FILMING_LOCATION"])
       .reset_index(drop=True)
   )
   
   dim_production["ID_PRODUCTION"] = dim_production.index + 1
   
   dim_production.head(2)

8. Criação da dimensão de datas com informações de ano, mês e trimestre de lançamento.

   dim_date = df_silver["US_RELEASE_DATE"].dropna().drop_duplicates().sort_values(by="US_RELEASE_DATE").reset_index(drop=True)
   
   dim_date["YEAR"] = dim_date["US_RELEASE_DATE"].dt.year
   dim_date["MONTH"] = dim_date["US_RELEASE_DATE"].dt.month
   dim_date["QUARTER"] = dim_date["US_RELEASE_DATE"].dt.quarter
   
   dim_date["ID_DATE"] = dim_date["US_RELEASE_DATE"].dt.strftime("%Y%m%d").astype(int)
   
   dim_date.head(2)

9. Criação inicial da tabela fato a partir dos dados completos da camada Silver.

   fact_movies = df_silver.copy()

10. Associação da dimensão de filmes à tabela fato por meio das chaves correspondentes.

    fact_movies = fact_movies.merge(
        dim_film,
        on=["FILM", "GENRE", "RATING_MPA", "LANGUAGE", "BREAK_EVEN", "MCU", "MALE_FEMALE_LED", "PHASE"],
        how="left",
    )

11. Associação da dimensão de equipe técnica à tabela fato.

    fact_movies = fact_movies.merge(
        dim_staff,
        on=["DIRECTOR", "WRITER", "STAR"],
        how="left",
    )

12. Associação da dimensão de franquias à tabela fato.

    fact_movies = fact_movies.merge(
        dim_franchise,
        on=["FRANCHISE", "CHARACTER_FAMILY"],
        how="left",
    )

13. Associação da dimensão de produção à tabela fato.

    fact_movies = fact_movies.merge(
        dim_production,
        on=["PRODUCTION_COMPANY", "DISTRIBUTOR", "COUNTRY_ORIGIN", "FILMING_LOCATION"],
        how="left",
    )

14. Associação da dimensão de datas à tabela fato utilizando a data de lançamento.

    fact_movies = fact_movies.merge(
        dim_date,
        on=["US_RELEASE_DATE"],
        how="left",
    )

15. Seleção final das chaves dimensionais e métricas numéricas da tabela fato.

    fact_movies = fact_movies[
        [
            "ID_FILM", "ID_STAFF", "ID_FRANCHISE", "ID_PRODUCTION",
            "ID_DATE", "BUDGET_x", "INFLATION_ADJUSTED_BUDGET",
            "GROSS_WORLD_WIDE", "INFLATION_ADJUSTED_WORLDWIDE_GROSS",
            "GROSS_US_CANADA", "DOMESTIC", "BOX_OFFICE_GROSS_OTHER_TERRITORIES",
            "GROSS_OPENING_WEEKEND", "GROSS_TO_BUDGET",
            "RATING_IMDB", "ROTTEN_TOMATOES_CRITIC_SCORE",
            "VOTE", "OSCAR", "NOMINATION", "WIN", "MINUTES"
        ]
    ]

16. Visualização inicial da tabela fato já estruturada no modelo Star Schema.

    fact_movies.head(3)

17. Envio das tabelas dimensionais e fato para a camada Gold no BigQuery.

    minhas_tabelas = {
        "dim_date": dim_date,
        "dim_film": dim_film,
        "dim_franchise": dim_franchise,
        "dim_production": dim_production,
        "dim_staff": dim_staff,
        "fact_movies": fact_movies,
    }
    
    for key, value in minhas_tabelas.items():
        print(key)
    
        value.to_gbq(
            project_id=gcp_id_do_projeto,
            destination_table=f"gold.{key}",
            if_exists="replace",
            credentials=my_gcp_cred,
        )

18. Definição das chaves primárias das tabelas dimensionais no BigQuery.

    ALTER TABLE gold.dim_date
    ADD PRIMARY KEY (ID_DATE) NOT ENFORCED;
    
    ALTER TABLE gold.dim_film
    ADD PRIMARY KEY (ID_FILM) NOT ENFORCED;
    
    ALTER TABLE gold.dim_franchise
    ADD PRIMARY KEY (ID_FRANCHISE) NOT ENFORCED;
    
    ALTER TABLE gold.dim_production
    ADD PRIMARY KEY (ID_PRODUCTION) NOT ENFORCED;
    
    ALTER TABLE gold.dim_staff
    ADD PRIMARY KEY (ID_STAFF) NOT ENFORCED;

19. Criação das chaves estrangeiras da tabela fato para garantir o relacionamento com as dimensões.

    ALTER TABLE gold.fact_movies ADD CONSTRAINT fk_date
    FOREIGN KEY (ID_DATE) REFERENCES gold.dim_date (ID_DATE)
    NOT ENFORCED;
    
    ALTER TABLE gold.fact_movies ADD CONSTRAINT fk_film
    FOREIGN KEY (ID_FILM) REFERENCES gold.dim_film (ID_FILM)
    NOT ENFORCED;
    
    ALTER TABLE gold.fact_movies ADD CONSTRAINT fk_franchise
    FOREIGN KEY (ID_FRANCHISE) REFERENCES gold.dim_franchise (ID_FRANCHISE)
    NOT ENFORCED;
    
    ALTER TABLE gold.fact_movies ADD CONSTRAINT fk_production
    FOREIGN KEY (ID_PRODUCTION) REFERENCES gold.dim_production (ID_PRODUCTION)
    NOT ENFORCED;
    
    ALTER TABLE gold.fact_movies ADD CONSTRAINT fk_staff
    FOREIGN KEY (ID_STAFF) REFERENCES gold.dim_staff (ID_STAFF)
    NOT ENFORCED;

EXTRAS

ℹ️ Clique para ver os detalhes

The Movie Database (TMDB)

• Crie e configure o acesso à API do TMDB
  • 1º Criar conta: https://themoviedb.org/signup
  • 2º Solicitar chave da API: https://themoviedb.org/settings/api/request
  • 3º Configurações da API: https://themoviedb.org/settings/api

[!NOTE] Leia a documentação: https://pypi.org/project/tmdbsimple

1. Define a chave de autenticação da API do TMDB.

   import tmdbsimple as tmdb
   
   tmdb_api_key = "_____"
   tmdb.API_KEY = tmdb_api_key

2. Busca informações de filmes no TMDB.

   tmdb_movies = tmdb.Search().movie(query="Spider-Man 2")
   
   tmdb_data = tmdb_movies.get("results")
   
   pd.DataFrame(data=tmdb_data)

3. Busca o ID de uma pessoa/artista no TMDB.

   star_id = tmdb.Search().person(query="Tony Ramos").get("results")[0].get("id")

4. Obtém redes sociais cadastradas de uma pessoa no TMDB.

   tmdb.People(star_id).external_ids().get("instagram_id")

Igmapper

[!NOTE] Leia a documentação: https://pypi.org/project/igmapper

1. Configura o cliente de acesso ao Instagram via Igmapper.

   import igmapper
   
   client = igmapper.InstaClient(
       csrftoken=None,
       ds_user_id=None,
       sessionid=None,
       use_curl=True
   )

2. Obtém informações públicas de um perfil do Instagram.

   client.get_profile_info("therock")

3. Obtém as publicações do feed de um perfil do Instagram.

   client.get_feed("therock")