I denne udfordring fokuseres der på at gøre dine API-forespørgsler mere pålidelige ved at håndtere fejl på en hensigtsmæssig måde. Ved arbejde med API'er er det almindeligt at støde på problemer såsom forkerte URL'er, netværksproblemer eller uventede svar. Evnen til at opdage disse problemer og reagere passende er en væsentlig færdighed for robuste API-integrationer. Målet er at anmode om en kattefakta fra Cat Facts API. Hvis der opstår problemer—såsom netværksfejl eller ugyldigt svar—skal din kode udskrive en tydelig besked, der angiver fejlen.


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

class TestTask(unittest.TestCase):
    def test_successful_cat_fact(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.get_cat_fact()
        output = normalize_text(f.getvalue())
        # Should print a non-empty string that is not the failure message
        _dynamic_test(
            self,
            output.strip() != "" and "failed to retrieve cat fact." not in output,
            "Prints a cat fact when the request is successful.",
            f"Expected a cat fact, got: '{output.strip()}'",
        )

    def test_network_error(self):
        # Patch requests.get to raise a ConnectionError
        import user_code
        import types
        import requests
        import builtins
        
        def fake_get(*args, **kwargs):
            raise requests.exceptions.ConnectionError("Network down")

        real_get = requests.get
        requests.get = fake_get
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
            user_code.get_cat_fact()
        output = normalize_text(f.getvalue())
        requests.get = real_get
        expected = normalize_text("Failed to retrieve cat fact.")
        _dynamic_test(
            self,
            expected in output,
            "Prints failure message on network error.",
            f"Expected failure message, got: '{output.strip()}'",
        )

    def test_invalid_url(self):
        # Change the URL to an invalid one
        code = ""
        with open("user_code.py", "r") as f:
            code = f.read()
        code = code.replace('"https://catfact.ninja/fact"', '"https://invalid-url-for-cat-fact-api.com"')
        ns = {}
        import requests
        import io
        from contextlib import redirect_stdout
        f = io.StringIO()
        with redirect_stdout(f):
            exec(code, ns)
            ns['get_cat_fact']()
        output = normalize_text(f.getvalue())
        expected = normalize_text("Failed to retrieve cat fact.")
        _dynamic_test(
            self,
            expected in output,
            "Prints failure message on invalid URL.",
            f"Expected failure message, got: '{output.strip()}'",
        )

    def test_invalid_json(self):
        # Patch requests.get to return a response with invalid json
        import user_code
        import requests
        class FakeResponse:
            def raise_for_status(self):
                return None
            def json(self):
                raise ValueError("No JSON")
        def fake_get(*args, **kwargs):
            return FakeResponse()
        real_get = requests.get
        requests.get = fake_get
        import io
        from contextlib import redirect_stdout
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
            user_code.get_cat_fact()
        output = normalize_text(f.getvalue())
        requests.get = real_get
        expected = normalize_text("Failed to retrieve cat fact.")
        _dynamic_test(
            self,
            expected in output,
            "Prints failure message on invalid JSON response.",
            f"Expected failure message, got: '{output.strip()}'",
        )

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

Lær at interagere med åbne API'er ved hjælp af Python, behandle og analysere data fra virkelige webtjenester, samt opbygge praktiske applikationer uden behov for registrering eller betaling. Dette kursus er designet til øvede Python-brugere, der ønsker at udvide deres færdigheder inden for datahentning og -manipulation ved hjælp af API'er.

Lær de grundlæggende begreber om API'er, hvordan man foretager HTTP-forespørgsler i Python, og hvordan man håndterer svar fra åbne API'er.

Gå i dybden med arbejdet med åbne API'er ved at hente og analysere offentlige data, såsom vejr- og rumrelaterede informationer.

Anvendelse af avancerede teknikker til arbejde med API'er, herunder håndtering af forespørgselsparametre, behandling af datalister og grundlæggende datavisualisering.

Udfordring: Fejlhåndtering med API'er

Løsning