In deze uitdaging gebruik je de Open-Meteo API om actuele weergegevens voor Berlijn op te halen en belangrijke informatie weer te geven. De Open-Meteo API levert weergegevens voor elke locatie die wordt gespecificeerd door breedte- en lengtegraad. Voor Berlijn is de breedtegraad 52.52 en de lengtegraad 13.41. Het doel is om de huidige temperatuur en windsnelheid voor Berlijn op te halen en deze in een specifiek formaat weer te geven. Deze oefening versterkt je vaardigheden in het uitvoeren van HTTP-verzoeken, het parseren van JSON-antwoorden en het extraheren van relevante gegevens uit API's.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout
import sys

class MockResponse:
    def __init__(self, json_data):
        self._json_data = json_data
    def json(self):
        return self._json_data

def _mock_requests_get(*args, **kwargs):
    mock_response = {
        "current_weather": {
            "temperature": 17.5,
            "windspeed": 4.8
        }
    }
    return MockResponse(mock_response)

class TestTask(unittest.TestCase):
    def setUp(self):
        # Patch requests.get
        self._real_requests = sys.modules.get('requests')
        import types
        self.requests_mock = types.SimpleNamespace(**vars(self._real_requests))
        self._orig_get = self._real_requests.get
        self._real_requests.get = _mock_requests_get

    def tearDown(self):
        # Restore requests.get
        if self._real_requests:
            self._real_requests.get = self._orig_get

    def test_temperature_extraction(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.fetch_berlin_weather()
        output = f.getvalue()
        _dynamic_test(
            self,
            "17.5" in output,
            "Temperature value is correctly extracted from API response.",
            f"Temperature value 17.5 not found in output: {output}"
        )

    def test_windspeed_extraction(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.fetch_berlin_weather()
        output = f.getvalue()
        _dynamic_test(
            self,
            "4.8" in output,
            "Windspeed value is correctly extracted from API response.",
            f"Windspeed value 4.8 not found in output: {output}"
        )

    def test_output_format(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.fetch_berlin_weather()
        output = normalize_text(f.getvalue())
        expected = normalize_text("Temperature: 17.5°C, Wind Speed: 4.8 m/s")
        _dynamic_test(
            self,
            expected in output,
            "Output format matches required format.",
            f"Expected output '{expected}' not found in: {output}"
        )

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

Leer hoe je met open API's kunt werken met Python, gegevens van echte webservices kunt verwerken en analyseren, en praktische toepassingen kunt bouwen zonder registratie of betaling. Deze cursus is bedoeld voor gevorderde Python-gebruikers die hun vaardigheden in gegevensopvraging en -verwerking met API's willen uitbreiden.

Leer de kernconcepten van API's, hoe HTTP-verzoeken in Python worden gedaan en hoe reacties van open API's worden verwerkt.

Verdiep je verder in het werken met open API's door het ophalen en analyseren van openbare gegevens, zoals weer- en ruimte-informatie.

Geavanceerde technieken toepassen voor het werken met API's, waaronder het omgaan met queryparameters, het verwerken van lijsten met gegevens en basisgegevensvisualisatie.

Uitdaging: Weerdata-Analyzer

Oplossing