In this challenge, you will put your skills to the test by working with a fun and straightforward public API. Your goal is to use the Cat Facts API to fetch and display three random cat facts. This exercise will give you hands-on practice making HTTP requests using the `requests` library and handling JSON data returned from an API. You will see how to extract specific information from the response and present it clearly to the user. By the end of this task, you will have reinforced your understanding of the basics of interacting with web APIs in Python.


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

class TestTask(unittest.TestCase):
    def test_three_requests_and_output(self):
        import user_code
        importlib.reload(user_code)
        
        # Patch requests.get to count calls and simulate API responses
        import requests
        original_get = requests.get
        call_count = {'count': 0}
        facts = [
            {'fact': 'Cats have five toes on their front paws.'},
            {'fact': 'A group of cats is called a clowder.'},
            {'fact': 'Cats sleep for 70% of their lives.'}
        ]
        
        def fake_get(url, *args, **kwargs):
            call_count['count'] += 1
            class FakeResponse:
                def json(self_inner):
                    return facts[call_count['count']-1]
            return FakeResponse()
        
        requests.get = fake_get
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue().strip().split('\\n')
        requests.get = original_get
        
        _dynamic_test(
            self,
            call_count['count'] == 3,
            "Function makes three requests to the API",
            f"Expected 3 requests, got {call_count['count']}"
        )
        expected_facts = [fact['fact'] for fact in facts]
        _dynamic_test(
            self,
            len(output) == 3,
            "Function prints exactly three cat facts",
            f"Expected 3 lines of output, got {len(output)}: {output}"
        )
        for i in range(3):
            _dynamic_test(
                self,
                output[i] == expected_facts[i],
                f"Fact {i+1} matches expected output",
                f"Expected: '{expected_facts[i]}', got: '{output[i]}'"
            )
    
    def test_fact_extracted_from_json(self):
        import user_code
        importlib.reload(user_code)
        import requests
        original_get = requests.get
        call_args = []
        def fake_get(url, *args, **kwargs):
            call_args.append(url)
            class FakeResponse:
                def json(self_inner):
                    return {"fact": "Test fact extraction"}
            return FakeResponse()
        requests.get = fake_get
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = f.getvalue().strip().split('\\n')
        requests.get = original_get
        _dynamic_test(
            self,
            all(url == "https://catfact.ninja/fact" for url in call_args),
            "All requests made to correct API endpoint",
            f"Not all requests made to correct endpoint: {call_args}"
        )
        _dynamic_test(
            self,
            all(line == "Test fact extraction" for line in output),
            "Fact is extracted from 'fact' key in JSON response",
            f"Expected all lines to be 'Test fact extraction', got: {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

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: Retrieve and Display Cat Facts

Solution

Challenge: Retrieve and Display Cat Facts

Solution