🌐 Lesson 8.3: Making API Requests

import requests  # pip install requests

# --- Basic GET request ---
response = requests.get("https://api.github.com/users/github")

print(response.status_code)   # 200
print(type(response))         # <class 'requests.models.Response'>

# The response body is a JSON string — parse it:
data = response.json()        # Shortcut for json.loads(response.text)
print(data["name"])           # GitHub
print(data["public_repos"])   # (number of public repos)
print(data["bio"])            # How people build software.

# --- You can also get the raw text ---
print(response.text[:100])    # First 100 chars of raw JSON string

# --- Response headers ---
print(response.headers["content-type"])   # application/json; charset=utf-8

# --- Install requests if you haven't ---
# pip install requests
# (or: pip install requests --break-system-packages on some systems)
# 'requests' is not built-in — it's the most popular Python package

// --- Node.js 18+ has built-in fetch! ---
// (Older Node.js: npm install node-fetch)

// Method 1: async/await (recommended)
async function getGitHubUser() {
    const response = await fetch("https://api.github.com/users/github");

    console.log(response.status);     // 200
    console.log(response.ok);         // true (status 200-299)

    const data = await response.json();  // Parse JSON body
    console.log(data.name);              // GitHub
    console.log(data.public_repos);      // (number)
    console.log(data.bio);              // How people build software.
}

getGitHubUser();

// Method 2: .then() chain
fetch("https://api.github.com/users/github")
    .then(response => response.json())
    .then(data => console.log(data.name))
    .catch(err => console.error("Error:", err));

// --- Response headers ---
async function showHeaders() {
    const response = await fetch("https://api.github.com/users/github");
    console.log(response.headers.get("content-type"));
    // application/json; charset=utf-8
}
showHeaders();

using System.Net.Http;
using System.Text.Json;

// --- HttpClient is C#'s built-in HTTP library ---
// Create ONE HttpClient and reuse it (important for performance!)
HttpClient client = new HttpClient();

// Basic GET request:
HttpResponseMessage response = await client.GetAsync(
    "https://api.github.com/users/github"
);
// GitHub API requires a User-Agent header:
client.DefaultRequestHeaders.Add("User-Agent", "MyApp");

Console.WriteLine((int)response.StatusCode);  // 200
Console.WriteLine(response.IsSuccessStatusCode);  // True

// Read and parse JSON:
string jsonText = await response.Content.ReadAsStringAsync();
JsonDocument doc = JsonDocument.Parse(jsonText);
JsonElement root = doc.RootElement;

Console.WriteLine(root.GetProperty("name").GetString());  // GitHub
Console.WriteLine(root.GetProperty("public_repos").GetInt32());

// --- Shortcut: GetStringAsync ---
string json = await client.GetStringAsync(
    "https://api.github.com/users/github"
);
var data = JsonDocument.Parse(json).RootElement;

// --- Deserialize to a class ---
class GitHubUser
{
    public string Name { get; set; } = "";
    public int PublicRepos { get; set; }
    public string? Bio { get; set; }
}

var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
var user = JsonSerializer.Deserialize<GitHubUser>(json, options);
Console.WriteLine(user?.Name);  // GitHub

import requests
import json

# Fetch data about a GitHub repository
response = requests.get("https://api.github.com/repos/python/cpython")
repo = response.json()

# Step 1: Explore the response — see what fields are available
# Pretty-print the keys:
print(json.dumps(list(repo.keys()), indent=2))

# Step 2: Extract what you need
print(f"Name: {repo['name']}")                 # cpython
print(f"Stars: {repo['stargazers_count']}")    # (large number)
print(f"Language: {repo['language']}")          # Python
print(f"Open Issues: {repo['open_issues']}")
print(f"Description: {repo['description']}")

# Step 3: Navigate nested data
print(f"Owner: {repo['owner']['login']}")       # python
print(f"Owner Avatar: {repo['owner']['avatar_url']}")

# Step 4: Handle missing fields safely
license_name = repo.get("license", {}).get("name", "Unknown")
print(f"License: {license_name}")

# Pro tip: During development, dump the whole response to see its shape:
# print(json.dumps(repo, indent=2))  # Shows everything, nicely formatted

async function exploreRepo() {
    const response = await fetch("https://api.github.com/repos/nodejs/node");
    const repo = await response.json();

    // Step 1: Explore — see what's available
    console.log(Object.keys(repo));

    // Step 2: Extract what you need
    console.log(`Name: ${repo.name}`);                  // node
    console.log(`Stars: ${repo.stargazers_count}`);
    console.log(`Language: ${repo.language}`);           // JavaScript (or C++)
    console.log(`Open Issues: ${repo.open_issues}`);

    // Step 3: Navigate nested data
    console.log(`Owner: ${repo.owner.login}`);           // nodejs
    console.log(`Owner Avatar: ${repo.owner.avatar_url}`);

    // Step 4: Handle missing fields safely with optional chaining
    console.log(`License: ${repo.license?.name ?? "Unknown"}`);

    // Pro tip: During development, dump everything:
    // console.log(JSON.stringify(repo, null, 2));
}
exploreRepo();

HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("User-Agent", "MyApp");

string json = await client.GetStringAsync(
    "https://api.github.com/repos/dotnet/runtime"
);
JsonDocument doc = JsonDocument.Parse(json);
JsonElement repo = doc.RootElement;

// Step 1: Explore — list available properties
foreach (JsonProperty prop in repo.EnumerateObject())
    Console.WriteLine(prop.Name);

// Step 2: Extract what you need
Console.WriteLine($"Name: {repo.GetProperty("name").GetString()}");
Console.WriteLine($"Stars: {repo.GetProperty("stargazers_count").GetInt32()}");
Console.WriteLine($"Language: {repo.GetProperty("language").GetString()}");

// Step 3: Navigate nested data
Console.WriteLine($"Owner: {repo.GetProperty("owner").GetProperty("login").GetString()}");

// Step 4: Handle missing fields safely
string licenseName = "Unknown";
if (repo.TryGetProperty("license", out JsonElement licenseEl) &&
    licenseEl.ValueKind != JsonValueKind.Null &&
    licenseEl.TryGetProperty("name", out JsonElement nameEl))
{
    licenseName = nameEl.GetString() ?? "Unknown";
}
Console.WriteLine($"License: {licenseName}");

import requests

# --- Method 1: params dictionary (recommended!) ---
# requests builds the URL for you and handles encoding
response = requests.get(
    "https://api.github.com/search/repositories",
    params={
        "q": "language:python stars:>10000",
        "sort": "stars",
        "order": "desc",
        "per_page": 5,
    }
)
data = response.json()

print(f"Total results: {data['total_count']}")
for repo in data["items"]:
    print(f"  ⭐ {repo['stargazers_count']:,}  {repo['full_name']}")
    print(f"     {repo['description'][:60]}...")

# requests built this URL automatically:
print(response.url)
# https://api.github.com/search/repositories?q=language%3Apython+stars%3A%3E10000&sort=stars&...

# --- Method 2: URL string (works but messy) ---
# You'd have to manually encode special characters
url = "https://api.github.com/search/repositories?q=python&sort=stars"
response = requests.get(url)

# Always prefer the params dict — it handles:
# - URL encoding (spaces → %20, : → %3A)
# - Special characters
# - Building the URL correctly

// --- Method 1: URLSearchParams (recommended!) ---
async function searchRepos() {
    const params = new URLSearchParams({
        q: "language:javascript stars:>10000",
        sort: "stars",
        order: "desc",
        per_page: "5",    // URLSearchParams values must be strings
    });

    const url = `https://api.github.com/search/repositories?${params}`;
    const response = await fetch(url);
    const data = await response.json();

    console.log(`Total results: ${data.total_count}`);
    for (let repo of data.items) {
        console.log(`  ⭐ ${repo.stargazers_count.toLocaleString()}  ${repo.full_name}`);
        console.log(`     ${repo.description?.slice(0, 60)}...`);
    }
}
searchRepos();

// --- Method 2: Template literal (simpler for few params) ---
async function searchSimple(language) {
    let url = `https://api.github.com/search/repositories?q=language:${language}&sort=stars&per_page=3`;
    let response = await fetch(url);
    let data = await response.json();
    return data.items;
}

// URLSearchParams handles encoding automatically:
let params = new URLSearchParams({ q: "hello world" });
console.log(params.toString());  // q=hello+world

using System.Web;

HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("User-Agent", "MyApp");

// --- Method 1: UriBuilder + query string ---
var builder = new UriBuilder("https://api.github.com/search/repositories");
var query = HttpUtility.ParseQueryString(string.Empty);
query["q"] = "language:csharp stars:>5000";
query["sort"] = "stars";
query["order"] = "desc";
query["per_page"] = "5";
builder.Query = query.ToString();

string json = await client.GetStringAsync(builder.ToString());
JsonDocument doc = JsonDocument.Parse(json);
JsonElement root = doc.RootElement;

Console.WriteLine($"Total: {root.GetProperty("total_count").GetInt32()}");
foreach (JsonElement repo in root.GetProperty("items").EnumerateArray())
{
    string name = repo.GetProperty("full_name").GetString()!;
    int stars = repo.GetProperty("stargazers_count").GetInt32();
    Console.WriteLine($"  ⭐ {stars:N0}  {name}");
}

// --- Method 2: String interpolation (simpler cases) ---
string lang = "csharp";
string url = $"https://api.github.com/search/repositories?q=language:{lang}&sort=stars";
string simpleJson = await client.GetStringAsync(url);

import requests

def fetch_user(username):
    """Fetch a GitHub user's profile with full error handling."""
    url = f"https://api.github.com/users/{username}"

    try:
        response = requests.get(url, timeout=10)  # 10-second timeout

        # Check for HTTP errors (4xx and 5xx)
        if response.status_code == 404:
            print(f"User '{username}' not found.")
            return None
        elif response.status_code == 403:
            print("Access forbidden — you may have hit the rate limit.")
            print(f"Rate limit resets at: {response.headers.get('X-RateLimit-Reset')}")
            return None
        elif response.status_code != 200:
            print(f"Error: HTTP {response.status_code}")
            return None

        return response.json()

    except requests.exceptions.ConnectionError:
        print("Error: Could not connect. Check your internet connection.")
        return None
    except requests.exceptions.Timeout:
        print("Error: Request timed out. The server may be slow.")
        return None
    except requests.exceptions.JSONDecodeError:
        print("Error: Response was not valid JSON.")
        return None
    except requests.exceptions.RequestException as e:
        print(f"Error: {e}")
        return None

# Usage:
user = fetch_user("octocat")
if user:
    print(f"Found: {user['name']} ({user['login']})")

user = fetch_user("this-user-definitely-does-not-exist-12345")
# User 'this-user-definitely-does-not-exist-12345' not found.

async function fetchUser(username) {
    const url = `https://api.github.com/users/${username}`;

    try {
        // AbortController for timeout
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), 10000);

        const response = await fetch(url, { signal: controller.signal });
        clearTimeout(timeoutId);

        // Check HTTP status
        if (response.status === 404) {
            console.log(`User '${username}' not found.`);
            return null;
        }
        if (response.status === 403) {
            console.log("Access forbidden — rate limit may be hit.");
            return null;
        }
        if (!response.ok) {
            console.log(`Error: HTTP ${response.status}`);
            return null;
        }

        return await response.json();

    } catch (err) {
        if (err.name === "AbortError") {
            console.log("Error: Request timed out.");
        } else if (err.name === "TypeError") {
            // fetch throws TypeError for network failures
            console.log("Error: Network failure. Check your connection.");
        } else {
            console.log(`Error: ${err.message}`);
        }
        return null;
    }
}

// Usage:
let user = await fetchUser("octocat");
if (user) console.log(`Found: ${user.name} (${user.login})`);

await fetchUser("this-user-definitely-does-not-exist-12345");
// User 'this-user-definitely-does-not-exist-12345' not found.

using System.Net.Http;
using System.Text.Json;

HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("User-Agent", "MyApp");
client.Timeout = TimeSpan.FromSeconds(10);

async Task<JsonElement?> FetchUser(string username)
{
    string url = $"https://api.github.com/users/{username}";

    try
    {
        HttpResponseMessage response = await client.GetAsync(url);

        if (response.StatusCode == System.Net.HttpStatusCode.NotFound)
        {
            Console.WriteLine($"User '{username}' not found.");
            return null;
        }
        if (response.StatusCode == System.Net.HttpStatusCode.Forbidden)
        {
            Console.WriteLine("Access forbidden — rate limit may be hit.");
            return null;
        }
        if (!response.IsSuccessStatusCode)
        {
            Console.WriteLine($"Error: HTTP {(int)response.StatusCode}");
            return null;
        }

        string json = await response.Content.ReadAsStringAsync();
        return JsonDocument.Parse(json).RootElement;
    }
    catch (TaskCanceledException)
    {
        Console.WriteLine("Error: Request timed out.");
        return null;
    }
    catch (HttpRequestException ex)
    {
        Console.WriteLine($"Error: {ex.Message}");
        return null;
    }
}

// Usage:
var user = await FetchUser("octocat");
if (user.HasValue)
    Console.WriteLine($"Found: {user.Value.GetProperty("name").GetString()}");

import requests
import os

# --- NEVER hard-code your API key! ---
# ❌ Bad: api_key = "abc123secret"  — anyone reading your code sees it!

# ✅ Good: Use an environment variable
api_key = os.environ.get("WEATHER_API_KEY")
if not api_key:
    print("Error: Set the WEATHER_API_KEY environment variable.")
    print("  export WEATHER_API_KEY=your_key_here  (Mac/Linux)")
    print("  set WEATHER_API_KEY=your_key_here      (Windows)")
    exit(1)

# Method 1: API key as a query parameter (most common)
response = requests.get(
    "https://api.weatherapi.com/v1/current.json",
    params={
        "key": api_key,
        "q": "Portland",
    }
)

# Method 2: API key in a header (some APIs prefer this)
response = requests.get(
    "https://api.example.com/data",
    headers={
        "Authorization": f"Bearer {api_key}",
        # or: "X-API-Key": api_key
    }
)

# --- Using a .env file (popular approach) ---
# 1. Create a file called .env:
#    WEATHER_API_KEY=abc123secret
#
# 2. Install python-dotenv: pip install python-dotenv
#
# 3. Load it in your code:
# from dotenv import load_dotenv
# load_dotenv()
# api_key = os.environ["WEATHER_API_KEY"]
#
# 4. Add .env to .gitignore so it's never committed!

// --- NEVER hard-code your API key! ---
// ❌ Bad: const apiKey = "abc123secret";

// ✅ Good: Use an environment variable
const apiKey = process.env.WEATHER_API_KEY;
if (!apiKey) {
    console.log("Error: Set the WEATHER_API_KEY environment variable.");
    process.exit(1);
}

// Method 1: API key as a query parameter
const params = new URLSearchParams({
    key: apiKey,
    q: "Portland",
});
const response = await fetch(
    `https://api.weatherapi.com/v1/current.json?${params}`
);

// Method 2: API key in a header
const response2 = await fetch("https://api.example.com/data", {
    headers: {
        "Authorization": `Bearer ${apiKey}`,
        // or: "X-API-Key": apiKey
    }
});

// --- Using a .env file with dotenv ---
// 1. Create .env file:  WEATHER_API_KEY=abc123secret
// 2. npm install dotenv
// 3. At top of your script:
//    require("dotenv").config();
//    const apiKey = process.env.WEATHER_API_KEY;
// 4. Add .env to .gitignore!

// --- NEVER hard-code your API key! ---
// ❌ Bad: string apiKey = "abc123secret";

// ✅ Good: Use an environment variable
string? apiKey = Environment.GetEnvironmentVariable("WEATHER_API_KEY");
if (string.IsNullOrEmpty(apiKey))
{
    Console.WriteLine("Error: Set the WEATHER_API_KEY environment variable.");
    return;
}

HttpClient client = new HttpClient();

// Method 1: API key as a query parameter
string url = $"https://api.weatherapi.com/v1/current.json?key={apiKey}&q=Portland";
string json = await client.GetStringAsync(url);

// Method 2: API key in a header
client.DefaultRequestHeaders.Add("Authorization", $"Bearer {apiKey}");
// or: client.DefaultRequestHeaders.Add("X-API-Key", apiKey);
string json2 = await client.GetStringAsync("https://api.example.com/data");

// --- Using appsettings.json or User Secrets ---
// For .NET projects, use the Secret Manager:
// dotnet user-secrets init
// dotnet user-secrets set "WeatherApiKey" "abc123secret"
// Then read with IConfiguration in your app.

import requests

def get_joke():
    response = requests.get(
        "https://official-joke-api.appspot.com/random_joke",
        timeout=10
    )
    if response.status_code != 200:
        return "Couldn't fetch a joke right now."

    joke = response.json()
    return f"{joke['setup']}\n...{joke['punchline']}"

print(get_joke())
# Why don't scientists trust atoms?
# ...Because they make up everything!

async function getJoke() {
    const response = await fetch(
        "https://official-joke-api.appspot.com/random_joke"
    );
    if (!response.ok) return "Couldn't fetch a joke right now.";

    const joke = await response.json();
    return `${joke.setup}\n...${joke.punchline}`;
}

console.log(await getJoke());

HttpClient client = new HttpClient();
string json = await client.GetStringAsync(
    "https://official-joke-api.appspot.com/random_joke"
);
var joke = JsonDocument.Parse(json).RootElement;
Console.WriteLine(joke.GetProperty("setup").GetString());
Console.WriteLine($"...{joke.GetProperty("punchline").GetString()}");

import requests

def get_weather(city):
    """Fetch weather using wttr.in (no API key needed!)"""
    # ?format=j1 returns JSON instead of the ASCII art version
    response = requests.get(
        f"https://wttr.in/{city}",
        params={"format": "j1"},
        timeout=10
    )
    if response.status_code != 200:
        print(f"Could not get weather for {city}")
        return

    data = response.json()
    current = data["current_condition"][0]

    temp_f = current["temp_F"]
    temp_c = current["temp_C"]
    desc = current["weatherDesc"][0]["value"]
    humidity = current["humidity"]
    wind = current["windspeedMiles"]

    print(f"\n🌤️ Weather in {city}:")
    print(f"   Temperature: {temp_f}°F ({temp_c}°C)")
    print(f"   Conditions:  {desc}")
    print(f"   Humidity:    {humidity}%")
    print(f"   Wind:        {wind} mph")

get_weather("Portland")
get_weather("Tokyo")
get_weather("London")

async function getWeather(city) {
    const params = new URLSearchParams({ format: "j1" });
    const response = await fetch(`https://wttr.in/${city}?${params}`);

    if (!response.ok) {
        console.log(`Could not get weather for ${city}`);
        return;
    }

    const data = await response.json();
    const current = data.current_condition[0];

    console.log(`\n🌤️ Weather in ${city}:`);
    console.log(`   Temperature: ${current.temp_F}°F (${current.temp_C}°C)`);
    console.log(`   Conditions:  ${current.weatherDesc[0].value}`);
    console.log(`   Humidity:    ${current.humidity}%`);
    console.log(`   Wind:        ${current.windspeedMiles} mph`);
}

await getWeather("Portland");
await getWeather("Tokyo");

HttpClient client = new HttpClient();

async Task GetWeather(string city)
{
    string url = $"https://wttr.in/{city}?format=j1";
    string json = await client.GetStringAsync(url);
    var root = JsonDocument.Parse(json).RootElement;
    var current = root.GetProperty("current_condition")[0];

    Console.WriteLine($"\n🌤️ Weather in {city}:");
    Console.WriteLine($"   Temp: {current.GetProperty("temp_F").GetString()}°F");
    Console.WriteLine($"   Conditions: {current.GetProperty("weatherDesc")[0].GetProperty("value").GetString()}");
    Console.WriteLine($"   Humidity: {current.GetProperty("humidity").GetString()}%");
}

await GetWeather("Portland");
await GetWeather("Tokyo");