# ── SETUP (once per machine) ──────────────────────────
git config --global user.name  "Ajay Kumar Gupt"
git config --global user.email "your@email.com"
git config --global core.editor "code --wait"  # VS Code as editor

# ── START A PROJECT ───────────────────────────────────
git init                        # initialise new repo in current dir
git clone <url>                 # clone existing repo from GitHub

# ── DAILY WORKFLOW ────────────────────────────────────
git status                      # what changed? (run this constantly)
git add .                       # stage all changes
git add src/main.py             # stage specific file
git commit -m "feat: add streaming response handler"
git push origin main            # push to GitHub
git pull origin main            # get latest changes

# ── HISTORY ───────────────────────────────────────────
git log --oneline               # compact commit history
git log --oneline --graph       # visualise branch graph
git diff                        # unstaged changes
git diff --staged               # staged changes (what will be committed)

# ── UNDO ──────────────────────────────────────────────
git restore <file>              # discard unstaged changes to a file
git restore --staged <file>     # unstage a file
git revert <commit-hash>        # undo a commit safely (creates new commit)

# Set an environment variable in the shell (temporary)
export OPENAI_API_KEY="sk-proj-..."
export ANTHROPIC_API_KEY="sk-ant-..."

# Read it back
echo $OPENAI_API_KEY

# Permanent — add to ~/.bashrc or ~/.zshrc
echo 'export OPENAI_API_KEY="sk-proj-..."' >> ~/.bashrc
source ~/.bashrc    # reload without restarting terminal

# In Python — the secure pattern for all AI projects
import os
from dotenv import load_dotenv

load_dotenv()   # reads .env file from project root
api_key = os.environ.get("OPENAI_API_KEY")

if not api_key:
    raise ValueError("OPENAI_API_KEY not set. Check your .env file.")

# .env file (in project root, never committed to Git)
# OPENAI_API_KEY=sk-proj-...
# ANTHROPIC_API_KEY=sk-ant-...
# DATABASE_URL=postgresql://...

# PATH — tells your shell where to find executables
echo $PATH     # colon-separated list of directories

# If 'python' command not found, your Python install dir is missing from PATH
which python   # where is Python installed?
which pip      # where is pip?

# Add a directory to PATH (in ~/.bashrc)
export PATH=$PATH:/home/user/.local/bin

import requests
import json

# GET request — read data
response = requests.get("https://api.open-meteo.com/v1/forecast",
    params={
        "latitude": 19.07,
        "longitude": 72.87,
        "daily": "temperature_2m_max",
        "timezone": "Asia/Kolkata"
    }
)

print(response.status_code)   # 200
data = response.json()         # parse JSON body

# POST request — send data (how LLM APIs work)
response = requests.post(
    "https://api.anthropic.com/v1/messages",
    headers={
        "x-api-key": api_key,
        "anthropic-version": "2023-06-01",
        "content-type": "application/json",
    },
    json={   # json= param auto-sets Content-Type and serialises
        "model": "claude-3-5-sonnet-20241022",
        "max_tokens": 1024,
        "messages": [{"role": "user", "content": "Hello!"}]
    }
)

# Always check status before using response
response.raise_for_status()   # raises HTTPError for 4xx/5xx
result = response.json()
print(result["content"][0]["text"])

# Robust request with timeout and error handling
def call_api(url: str, payload: dict, headers: dict) -> dict:
    try:
        response = requests.post(
            url,
            json=payload,
            headers=headers,
            timeout=30   # always set a timeout — never wait forever
        )
        response.raise_for_status()
        return response.json()
    except requests.exceptions.Timeout:
        print("Request timed out after 30s")
        return {}
    except requests.exceptions.HTTPError as e:
        print(f"HTTP {e.response.status_code}: {e.response.text}")
        return {}
    except requests.exceptions.ConnectionError:
        print("Cannot connect — check network / URL")
        return {}

import asyncio, httpx

# async def — defines a coroutine (NOT a regular function)
async def fetch_weather(city: str) -> dict:
    async with httpx.AsyncClient() as client:   # async HTTP client
        response = await client.get(
            "https://api.open-meteo.com/v1/forecast",
            params={"latitude": 19.07, "longitude": 72.87}
        )
        return response.json()

# await — pauses current coroutine until awaitable completes
# Can only use await INSIDE an async def function

# asyncio.gather — run multiple coroutines concurrently
async def fetch_all_cities():
    results = await asyncio.gather(
        fetch_weather("Mumbai"),
        fetch_weather("Delhi"),
        fetch_weather("Bangalore"),
    )
    return results

# asyncio.run — entry point for top-level async code
if __name__ == "__main__":
    results = asyncio.run(fetch_all_cities())

# Async context managers — async with
async with httpx.AsyncClient() as client:
    # client is available here, closed automatically after block
    response = await client.get(url)

# Async iteration — async for
async def stream_response():
    async with anthropic_client.messages.stream(...) as stream:
        async for text in stream.text_stream:
            print(text, end="", flush=True)

# asyncio.create_task — fire and forget (don't wait immediately)
async def main():
    task1 = asyncio.create_task(fetch_weather("Mumbai"))
    task2 = asyncio.create_task(fetch_weather("Delhi"))
    # ... do other work here ...
    result1 = await task1   # now wait for results
    result2 = await task2