In this challenge, you will deepen your skills in working with real-world APIs by retrieving and processing hourly temperature data for a specific location. You will use the Open-Meteo API to fetch temperature readings for Paris, France (latitude: 48.85, longitude: 2.35). The goal is to extract the hourly temperatures from the API's JSON response and print the first five values. This task will test your ability to make HTTP requests, parse JSON data, and access specific values within the data structure.


import unittest
import user_code
import ast
import re   
import unittest
from unittest.mock import patch, Mock
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    @patch('requests.get')
    def test_api_call_and_params(self, mock_get):
        import user_code
        importlib.reload(user_code)
        user_code.print_first_five_paris_temperatures()
        self.assertTrue(mock_get.called, "requests.get was not called.")
        args, kwargs = mock_get.call_args
        url = args[0] if args else kwargs.get('url')
        params = kwargs.get('params', {})
        _dynamic_test(
            self,
            url == 'https://api.open-meteo.com/v1/forecast',
            "Correct API endpoint used.",
            f"Incorrect API endpoint: {url}"
        )
        _dynamic_test(
            self,
            params.get('latitude') == 48.85 and params.get('longitude') == 2.35 and params.get('hourly') == 'temperature_2m',
            "Correct parameters used in API call.",
            f"Incorrect parameters: {params}"
        )

    @patch('requests.get')
    def test_extracts_and_prints_first_five_temperatures(self, mock_get):
        # Prepare mock response
        fake_temps = [14.2, 15.3, 16.1, 17.0, 18.4, 19.2, 20.1]
        mock_resp = Mock()
        mock_resp.json.return_value = {
            "hourly": {
                "temperature_2m": fake_temps
            }
        }
        mock_get.return_value = mock_resp
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_first_five_paris_temperatures()
        out_lines = [line.strip() for line in f.getvalue().splitlines() if line.strip()]
        expected = [str(t) for t in fake_temps[:5]]
        _dynamic_test(
            self,
            out_lines == expected,
            "First five temperature values printed correctly.",
            f"Expected output: {expected}, got: {out_lines}"
        )

    @patch('requests.get')
    def test_extracts_temperature_list(self, mock_get):
        fake_temps = [11, 12, 13, 14, 15, 16]
        mock_resp = Mock()
        mock_resp.json.return_value = {
            "hourly": {
                "temperature_2m": fake_temps
            }
        }
        mock_get.return_value = mock_resp
        import user_code
        importlib.reload(user_code)
        # Run function and check that it accesses the correct key
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_first_five_paris_temperatures()
        out_lines = [line.strip() for line in f.getvalue().splitlines() if line.strip()]
        _dynamic_test(
            self,
            out_lines == [str(x) for x in fake_temps[:5]],
            "Function extracts and prints first five from 'temperature_2m' list.",
            f"Expected: {fake_temps[:5]}, got: {out_lines}"
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\s{2,}", " ", text)
    text = re.sub(r"\s*([,:?])\s*", r"\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

Learn how to interact with open APIs using Python, process and analyze data from real-world web services, and build practical applications without the need for registration or payment. This course is designed for intermediate Python learners eager to expand their skills in data retrieval and manipulation using APIs.

Learn the core concepts of APIs, how to make HTTP requests in Python, and how to handle responses from open APIs.

Dive deeper into working with open APIs by retrieving and analyzing public data, such as weather and space information.

Apply advanced techniques for working with APIs, including handling query parameters, processing lists of data, and basic data visualization.

Challenge: Hourly Temperature Extractor

Solution

Challenge: Hourly Temperature Extractor

Solution