import logging

# Configure the logging system
# Sets the threshold for the logger to the DEBUG level
# This means all the logging messages at this level and above will be shown
logging.basicConfig(level=logging.DEBUG)

# Below are different levels of logging messages in increasing order of severity.

# DEBUG: Detailed information, typically of interest only when diagnosing problems.
logging.debug("This is a debug message")

# INFO: Confirmation that things are working as expected.
logging.info("This is an info message")

# WARNING: An indication that something unexpected happened, or indicative of some problem in the near future
# (e.g., ‘disk space low’). The software is still working as expected.
logging.warning("This is a warning message")

# ERROR: Due to a more serious problem, the software has not been able to perform some function.
logging.error("This is an error message")

# CRITICAL: A very serious error, indicating that the program itself may be unable to continue running.
logging.critical("This is a critical message")

import logging  # Import the logging module to enable logging of events, errors, and informational messages.

def divide(a, b):
    """Function to divide two numbers.

    Args:
    a (float): The numerator.
    b (float): The denominator.

    Returns:
    float: The result of the division if successful, otherwise None.
    """
    logging.info(f"Dividing {a} by {b}")  # Log an info message indicating the operation being performed.
    
    if b == 0:  # Check if the denominator is zero to avoid division by zero error.
        logging.error("Division by zero attempted")  # Log an error message if division by zero is attempted.
        return None  # Return None to indicate the operation failed.
    
    return a / b  # Perform the division and return the result.

if __name__ == "__main__":
    # Configure the logging to display messages of level DEBUG and above
    logging.basicConfig(level=logging.DEBUG)
    
    # Test the divide function with valid input
    result = divide(10, 2)
    print(f"Result: {result}")  # Output the result of the division

    # Test the divide function with division by zero
    result = divide(10, 0)
    print(f"Result: {result}")  # Output the result, which should be None because of division by zero

import logging

# Create a logger object with the name 'example_logger'
logger = logging.getLogger('example_logger')
# Set the logging level to DEBUG. This means that all messages with the level DEBUG and above will be logged
logger.setLevel(logging.DEBUG)

# Create a handler that will print log messages to the console (standard output)
console_handler = logging.StreamHandler()
# Create a handler that will write log messages to a file named 'example.log'
file_handler = logging.FileHandler('example.log')

# Define a formatter that specifies the format of the log messages
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# Set the formatter for the console handler
console_handler.setFormatter(formatter)
# Set the formatter for the file handler
file_handler.setFormatter(formatter)

# Add the console handler to the logger. This means that log messages will be output to the console
logger.addHandler(console_handler)
# Add the file handler to the logger. This means that log messages will be written to the 'example.log' file
logger.addHandler(file_handler)

# Log an informational message with the logger
logger.info('This is an informational message')

import logging  # Import the logging module to handle logging
from logging.handlers import RotatingFileHandler  # Import the RotatingFileHandler to create a rotating log system

# Create a logger object named 'rotating_logger'
logger = logging.getLogger('rotating_logger')
# Set the logging level to DEBUG so that all levels (DEBUG, INFO, WARNING, ERROR, and CRITICAL) will be logged
logger.setLevel(logging.DEBUG)

# Create a rotating file handler that will write to 'rotating_log.log'
# maxBytes=2000 means each log file can contain up to 2000 bytes
# backupCount=5 means the handler will keep up to 5 backup log files before overwriting the oldest one
rotating_handler = RotatingFileHandler('rotating_log.log', maxBytes=2000, backupCount=5)

# Define a format for the log messages
# The format includes the timestamp, logger's name, log level, and message
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# Apply the formatter to the rotating handler
rotating_handler.setFormatter(formatter)

# Add the rotating handler to the logger so it knows how to handle the logging
logger.addHandler(rotating_handler)

# Generate 100 debug log messages
for i in range(100):
    # Each debug message will contain the loop index
    logger.debug(f"Debug message {i}")

import logging

# Create a logger object with the name 'web_scraper_logger'
web_scraper_logger = logging.getLogger('web_scraper')

# Set the logging level to DEBUG. This means that all messages with the level DEBUG and above will be logged
web_scraper_logger.setLevel(logging.DEBUG)

# Create handlers that will print log messages to the console (standard output) write log messages to a file named 'web_scraper.log'
console_handler = logging.StreamHandler()
file_handler = logging.FileHandler('web_scraper.log')

# Define a formatter that specifies the format of the log messages
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# Set the formatter for the console handler and for the file handler
console_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)

# Add the console handler to the logger. This means that log messages will be output to the console
web_scraper_logger.addHandler(console_handler)
# Add the file handler to the logger. This means that log messages will be written to the 'example.log' file
web_scraper_logger.addHandler(file_handler)

import requests # Import the requests library to make HTTP requests
from bs4 import BeautifulSoup # Import the BeautifulSoup class from the bs4 library to parse HTML content 

def fetch_title(url):
    """
    Function to fetch the title of a webpage given its URL.
    
    Args:
        url (str): The URL of the webpage to scrape.

    Returns:
        str or None: The title of the webpage, or None if an error occurs.
    """
    
    # Log the start of the web scraping process
    web_scraper_logger.info(f"Starting to scrape the URL: {url}")
    
    try:
        # Send a GET request to the specified URL
        response = requests.get(url)
        
        # Raise an HTTPError exception for response codes 4xx or 5xx
        response.raise_for_status()
    except requests.RequestException as e:
        # Log the error if the HTTP request fails
        web_scraper_logger.error(f"HTTP Request failed: {e}")
        return None

    try:
        # Parse the HTML content of the response using BeautifulSoup
        soup = BeautifulSoup(response.content, 'html.parser')
        
        # Extract the content of the <title> tag
        title = soup.title.string
        
        # Log a message indicating successful extraction of the title
        web_scraper_logger.info(f"Successfully fetched the title: {title}")
        return title
    except Exception as e:
        # Log any errors that occur during HTML parsing or title extraction
        web_scraper_logger.error(f"Failed to parse HTML or extract title: {e}")
        return None

if __name__ == '__main__':
    urls = [
        'https://www.python.org',
        'https://www.example.com',
        'https://nonexistent.url'  # A URL that will cause a failed request
    ]

    for url in urls:
        title = fetch_title(url)
        if title:
            web_scraper_logger.debug(f"Scraped title for {url}: {title}")
        else:
            web_scraper_logger.warning(f"No title found for {url}")