Python Weather App Project Syllabus

What does "CLI" stand for and what defines a CLI application?

Command-Line Interface. It is a program operated by typing text commands and arguments in a terminal rather than through a graphical interface.

When planning a weather CLI's structure, what are the core functional components to separate?

Argument parsing (input), the API request layer (fetch), response handling/parsing, output formatting, and error handling. Separating them keeps code modular and testable.

What does a typical invocation of a weather CLI look like, and identify its parts?

E.g. `weather London --units metric`. `weather` is the command, `London` is a positional argument, and `--units metric` is an optional flag with a value.

Which standard-library module is the recommended way to parse command-line arguments in Python?

The `argparse` module. It parses arguments, generates help text, and validates input automatically.

Write the minimal code to create an argument parser and add a required positional `city` argument.

`import argparse` `parser = argparse.ArgumentParser()` `parser.add_argument("city")` `args = parser.parse_args()` — then access it as `args.city`.

How do you add an optional flag with a default value, such as `--units` defaulting to `metric`, in argparse?

`parser.add_argument("--units", default="metric", choices=["metric","imperial"])`. `choices` restricts valid values and `default` sets the fallback.

What automatic feature does argparse provide when a user runs the program with `-h` or `--help`?

It auto-generates and prints a usage message listing all arguments, their types, defaults, and help descriptions, then exits.

In argparse, how do you attach a help description to an argument?

Pass the `help` keyword, e.g. `parser.add_argument("city", help="Name of the city to look up")`. It appears in the `-h` output.

Write a basic `requests` call that sends a GET request to a weather API with query parameters.

`import requests` `response = requests.get(url, params={"q": city, "appid": key, "units": "metric"})`. The `params` dict is URL-encoded into the query string.

Why is passing query data via the `params` argument preferable to manually building the URL string?

`requests` automatically URL-encodes the values (handling spaces, special characters) and keeps the code readable and less error-prone.

What is the recommended way to set a timeout on a weather API request, and why?

Pass `timeout`, e.g. `requests.get(url, params=..., timeout=10)`. It prevents the program from hanging indefinitely if the server does not respond.

What does the HTTP status code 200 indicate in an API response?

200 OK means the request succeeded and the response body contains the requested data.

What do HTTP status codes 401 and 404 typically mean for a weather API request?

401 Unauthorized means an invalid or missing API key; 404 Not Found usually means the requested city/resource does not exist.

What does HTTP status code 429 indicate, and how should a CLI react?

429 Too Many Requests means you exceeded the rate limit. The CLI should inform the user and optionally back off and retry later.

In what format do most weather APIs return data, and how do you parse it with `requests`?

JSON. With `requests`, call `response.json()` to deserialize the body into a Python dictionary/list.

After calling `response.json()`, how would you extract a nested temperature value from `{"main": {"temp": 21.5}}`?

`data = response.json(); temp = data["main"]["temp"]`. Indexing the nested dict yields `21.5`.

What method on a `requests` response object raises an exception for HTTP error status codes?

`response.raise_for_status()`. It raises `requests.HTTPError` for 4xx and 5xx responses, letting you handle failures explicitly.

Why is it safer to use `dict.get("key")` instead of `dict["key"]` when reading parsed API data?

`get` returns `None` (or a default) if the key is missing instead of raising a `KeyError`, making the code more robust to unexpected response shapes.

What is the formula to convert a temperature from Kelvin (returned by some APIs) to Celsius?

$T_{\\text{C}} = T_{\\text{K}} - 273.15$, where $T_{\\text{K}}$ is the temperature in Kelvin.

What is the formula to convert a temperature from Celsius to Fahrenheit?

$T_{\\text{F}} = \\frac{9}{5}\\,T_{\\text{C}} + 32$, where $T_{\\text{C}}$ is degrees Celsius.

How can you format a floating-point temperature to one decimal place in a Python f-string?

Use a format spec, e.g. `f"{temp:.1f}"`. For `temp = 21.567` this yields `"21.6"`.

When formatting CLI output, why is alignment and labeling (e.g. "Temperature: 21.5C") important?

It makes the data human-readable and scannable, clearly associating each value with what it represents instead of dumping raw JSON.

What is the simplest way to display formatted weather results to the user in a CLI program?

Use the built-in `print()` function to write the formatted strings to standard output (stdout).

What is the difference between printing to stdout and stderr, and which should errors use?

stdout carries normal program output; stderr carries diagnostics and errors. Print error messages to stderr, e.g. `print(msg, file=sys.stderr)`, so they can be separated from data.

Why is testing a CLI with different inputs (valid city, invalid city, missing arguments) important?

It verifies the happy path and confirms the program handles edge cases and errors gracefully instead of crashing, improving reliability.

Give examples of edge-case inputs you should test in a weather CLI.

City names with spaces ("New York"), misspelled/nonexistent cities, empty input, special characters, different unit flags, and a missing/invalid API key.

Which Python construct is used to catch and handle runtime errors gracefully?

A `try` / `except` block. Code that may fail goes in `try`, and the handling logic goes in `except`, optionally catching specific exception types.

Which exception should you catch to handle network failures when using the `requests` library?

`requests.exceptions.RequestException` (the base class), or specific subclasses like `ConnectionError` and `Timeout`.

What is a good practice for the exit code of a CLI when an error occurs?

Exit with a non-zero status, e.g. `sys.exit(1)`. A zero exit code signals success; non-zero lets scripts and shells detect the failure.

What key elements should usage instructions for a CLI tool include?

Installation steps, how to set the API key, the command syntax with all arguments/flags, default values, and the expected output format.

Why should documentation include concrete usage examples, and give one for a weather CLI?

Examples let users copy a working command and see expected results immediately. Example: `python weather.py "New York" --units imperial` shows the current weather in Fahrenheit.