Dans ce défi, l'objectif est d'améliorer la fiabilité de vos requêtes API en gérant les erreurs de manière appropriée. Lors de l'utilisation d'API, il est courant de rencontrer des problèmes tels que des URL incorrectes, des problèmes de réseau ou des réponses inattendues. La capacité à détecter ces problèmes et à y répondre de façon adéquate constitue une compétence essentielle pour des intégrations API robustes. L'objectif est de demander un fait sur les chats à l'API Cat Facts. Cependant, si un problème survient—comme une défaillance réseau ou une réponse invalide—votre code doit afficher un message clair indiquant l'échec.


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

Apprenez à interagir avec des API ouvertes en Python, à traiter et analyser des données provenant de services web réels, et à développer des applications pratiques sans inscription ni paiement. Ce cours s'adresse aux apprenants intermédiaires en Python souhaitant approfondir leurs compétences en récupération et manipulation de données via des API.

Découvrez les concepts fondamentaux des API, la réalisation de requêtes HTTP en Python et la gestion des réponses provenant d'API ouvertes.

Approfondissement du travail avec les API ouvertes en récupérant et en analysant des données publiques, telles que les informations météorologiques et spatiales.

Appliquer des techniques avancées pour travailler avec des API, y compris la gestion des paramètres de requête, le traitement des listes de données et la visualisation basique des données.

Défi : Gestion des erreurs avec les API

Solution