import logging

# Configura o sistema de logging
# Define o limiar para o logger no nível DEBUG
# Isso significa que todas as mensagens de logging a partir deste nível serão mostradas
logging.basicConfig(level=logging.DEBUG)

# Abaixo estão diferentes níveis de mensagens de logging em ordem crescente de severidade.

# DEBUG: Informação detalhada, tipicamente de interesse apenas ao diagnosticar problemas.
logging.debug("Esta é uma mensagem de depuração")

# INFO: Confirmação de que as coisas estão funcionando como esperado.
logging.info("Esta é uma mensagem de informação")

# WARNING: Uma indicação de que algo inesperado aconteceu, ou indicativo de algum problema no futuro próximo
# (por exemplo, ‘espaço em disco baixo’). O software ainda está funcionando como esperado.
logging.warning("Esta é uma mensagem de aviso")

# ERROR: Devido a um problema mais sério, o software não conseguiu executar alguma função.
logging.error("Esta é uma mensagem de erro")

# CRITICAL: Um erro muito sério, indicando que o programa pode não conseguir continuar a execução.
logging.critical("Esta é uma mensagem crítica")

import logging  # Importa o módulo de logging para possibilitar o logging de eventos, erros e mensagens informativas.

def dividir(a, b):
    """Função para dividir dois números.

    Args:
    a (float): O numerador.
    b (float): O denominador.

    Returns:
    float: O resultado da divisão se bem-sucedida, caso contrário None.
    """
    logging.info(f"Dividindo {a} por {b}")  # Loga uma mensagem de info indicando a operação sendo realizada.
    
    if b == 0:  # Verifica se o denominador é zero para evitar erro de divisão por zero.
        logging.error("Tentativa de divisão por zero")  # Loga uma mensagem de erro se uma divisão por zero foi tentada.
        return None  # Retorna None para indicar que a operação falhou.
    
    return a / b  # Realiza a divisão e retorna o resultado.

if __name__ == "__main__":
    # Configura o logging para exibir mensagens do nível DEBUG e acima
    logging.basicConfig(level=logging.DEBUG)
    
    # Testa a função dividir com entrada válida
    resultado = dividir(10, 2)
    print(f"Resultado: {resultado}")  # Exibe o resultado da divisão

    # Testa a função dividir com divisão por zero
    resultado = dividir(10, 0)
    print(f"Resultado: {resultado}")  # Exibe o resultado, que deve ser None por causa da divisão por zero

import logging

# Cria um objeto logger com o nome 'exemplo_logger'
logger = logging.getLogger('exemplo_logger')
# Define o nível de logging para DEBUG. Isso significa que todas as mensagens com nível DEBUG e acima serão registradas
logger.setLevel(logging.DEBUG)

# Cria um handler que imprimirá mensagens de log no console (saída padrão)
console_handler = logging.StreamHandler()
# Cria um handler que escreverá mensagens de log em um arquivo chamado 'example.log'
file_handler = logging.FileHandler('exemplo.log')

# Define um formatter que especifica o formato das mensagens de log
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# Define o formatter para o console handler
console_handler.setFormatter(formatter)
# Define o formatter para o file handler
file_handler.setFormatter(formatter)

# Adiciona o console handler ao logger. Isso significa que mensagens de log serão exibidas no console
logger.addHandler(console_handler)
# Adiciona o file handler ao logger. Isso significa que mensagens de log serão escritas no arquivo 'example.log'
logger.addHandler(file_handler)

# Loga uma mensagem informativa com o logger
logger.info('Esta é uma mensagem informativa')

import logging  # Importa o módulo de logging para lidar com logs
from logging.handlers import RotatingFileHandler  # Importa o RotatingFileHandler para criar um sistema de log rotativo

# Cria um objeto de logger chamado 'rotating_logger'
logger = logging.getLogger('rotating_logger')
# Define o nível de logging para DEBUG para que todos os níveis (DEBUG, INFO, WARNING, ERROR e CRITICAL) sejam registrados
logger.setLevel(logging.DEBUG)

# Cria um handler de arquivo rotativo que escreverá no 'rotating_log.log'
# maxBytes=2000 significa que cada arquivo de log pode conter até 2000 bytes
# backupCount=5 significa que o handler manterá até 5 arquivos de log de backup antes de sobrescrever o mais antigo
rotating_handler = RotatingFileHandler('rotating_log.log', maxBytes=2000, backupCount=5)

# Define um formato para as mensagens de log
# O formato inclui o timestamp, nome do logger, nível do log e a mensagem
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# Aplica o formatter ao rotating handler
rotating_handler.setFormatter(formatter)

# Adiciona o rotating handler ao logger para que ele saiba como lidar com o logging
logger.addHandler(rotating_handler)

# Gera 100 mensagens de log de depuração
for i in range(100):
    # Cada mensagem de depuração conterá o índice do loop
    logger.debug(f"Mensagem de depuração {i}")

import logging

# Cria um objeto logger com o nome 'web_scraper_logger'
web_scraper_logger = logging.getLogger('web_scraper')

# Define o nível de logging para DEBUG. Isso significa que todas as mensagens com o nível DEBUG e superior serão registradas
web_scraper_logger.setLevel(logging.DEBUG)

# Cria handlers que irão imprimir mensagens de log no console (saída padrão) e escrever mensagens de log em um arquivo chamado 'web_scraper.log'
console_handler = logging.StreamHandler()
file_handler = logging.FileHandler('web_scraper.log')

# Define um formatter que especifica o formato das mensagens de log
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# Define o formatter para o console handler e para o file handler
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

# Adiciona o console handler ao logger. Isso significa que as mensagens de log serão exibidas no console
web_scraper_logger.addHandler(console_handler)
# Adiciona o file handler ao logger. Isso significa que as mensagens de log serão escritas no arquivo 'web_scraper.log'
web_scraper_logger.addHandler(file_handler)

import requests # Importa a biblioteca requests para fazer requisições HTTP
from bs4 import BeautifulSoup # Importa a classe BeautifulSoup da biblioteca bs4 para analisar conteúdo HTML 

def buscar_titulo(url):
    """
    Função para buscar o título de uma página da web dado o seu URL.

    Args:
        url (str): O URL da página da web a ser raspada.

    Retorna:
        str ou None: O título da página da web, ou None se ocorrer um erro.
    """

    # Registra o início do processo de raspagem da web
    web_scraper_logger.info(f"Iniciando a raspagem do URL: {url}")

    try:
        # Envia uma requisição GET para o URL especificado
        resposta = requests.get(url)

        # Levanta uma exceção HTTPError para códigos de resposta 4xx ou 5xx
        resposta.raise_for_status()
    except requests.RequestException as e:
        # Registra o erro se a requisição HTTP falhar
        web_scraper_logger.error(f"Falha na requisição HTTP: {e}")
        return None

    try:
        # Analisa o conteúdo HTML da resposta usando BeautifulSoup
        sopa = BeautifulSoup(resposta.content, 'html.parser')

        # Extrai o conteúdo da tag <title>
        titulo = sopa.title.string

        # Registra uma mensagem indicando a extração bem-sucedida do título
        web_scraper_logger.info(f"Título obtido com sucesso: {titulo}")
        return titulo
    except Exception as e:
        # Registra quaisquer erros que ocorram durante a análise de HTML ou extração do título
        web_scraper_logger.error(f"Falha ao analisar HTML ou extrair título: {e}")
        return None

if __name__ == '__main__':
    urls = [
        'https://www.python.org',
        'https://www.example.com',
        'https://urlinexistente.com.br'  # Uma URL que causará uma solicitação falhada
    ]

    for url in urls:
        titulo = buscar_titulo(url)
        if titulo:
            web_scraper_logger.debug(f"Título raspado para {url}: {titulo}")
        else:
            web_scraper_logger.warning(f"Nenhum título encontrado para {url}")