🔀 Git & Version Control

# Check if Git is installed
git --version

# Configure your identity (required before first commit)
git config --global user.name "Your Name"
git config --global user.email "you@example.com"

# Useful defaults
git config --global init.defaultBranch main
git config --global core.autocrlf true    # Windows
git config --global pull.rebase false     # merge on pull

# View all config
git config --list

# Create a new project and initialize Git
mkdir my-ds-project
cd my-ds-project
git init

# What happened? A hidden .git folder was created
ls -la .git/
# HEAD        — points to current branch
# config      — repo-level settings
# objects/    — stores all file content and history
# refs/       — branch and tag pointers

# Git has 3 areas:
# 1. Working Directory — your actual files
# 2. Staging Area (Index) — files ready to be committed
# 3. Repository (.git) — committed history

# See the current state
git status

# The workflow:
# edit files → git add (stage) → git commit (save snapshot)

echo "# My Project" > README.md
git status              # README.md is "untracked"
git add README.md       # Move to staging area
git status              # README.md is "staged"
git commit -m "Initial commit: add README"
git status              # "nothing to commit, working tree clean" 

# Stage specific files
git add file1.py file2.py

# Stage all changes in current directory
git add .

# Stage all tracked files (skip untracked)
git add -u

# Commit with a message
git commit -m "Add data loading and cleaning functions"

# Stage + commit tracked files in one step
git commit -am "Fix bug in feature extraction"

# Amend the last commit (fix message or add forgotten files)
git add forgotten_file.py
git commit --amend -m "Add data loading, cleaning, and forgotten_file" 

# Basic log
git log

# Compact one-line format
git log --oneline

# Show last 5 commits
git log --oneline -5

# Show with graph (branch visualization)
git log --oneline --graph --all

# Show what changed in each commit
git log --oneline --stat

# Search commit messages
git log --grep="fix" --oneline

# Commits by a specific author
git log --author="Alice" --oneline

# Commits in a date range
git log --since="2024-01-01" --until="2024-02-01" --oneline

# See unstaged changes (working dir vs staging)
git diff

# See staged changes (staging vs last commit)
git diff --staged

# Compare two commits
git diff abc123 def456

# Compare current branch with main
git diff main

# Show changes for a specific file
git diff -- src/model.py

# Show only file names that changed
git diff --name-only main

# Show word-level diff (great for text/notebooks)
git diff --word-diff

# Unstage a file (keep changes in working dir)
git restore --staged file.py

# Discard changes in working directory (CAREFUL — irreversible!)
git restore file.py

# Undo last commit but keep changes staged
git reset --soft HEAD~1

# Undo last commit, unstage changes (keep in working dir)
git reset HEAD~1

# Create a new commit that reverses a previous one (safe!)
git revert abc123

# View what a file looked like in a past commit
git show HEAD~3:src/model.py

# List all branches (* = current)
git branch

# Create a new branch
git branch feature/add-model

# Switch to it
git switch feature/add-model
# or older syntax: git checkout feature/add-model

# Create AND switch in one command
git switch -c feature/add-model
# or: git checkout -b feature/add-model

# List all branches including remote
git branch -a

# Rename a branch
git branch -m old-name new-name

# Delete a merged branch
git branch -d feature/add-model

# Force delete an unmerged branch (CAREFUL!)
git branch -D experiment/failed-approach

# Merge feature branch into main
git switch main
git merge feature/add-model

# Three types of merge:
# 1. Fast-forward — main hasn't diverged, just moves pointer
#    (clean, linear history)
git merge feature/add-model  # fast-forward if possible

# 2. No fast-forward — always creates a merge commit
#    (preserves branch history)
git merge --no-ff feature/add-model

# 3. Squash — combines all branch commits into one
#    (clean main history)
git merge --squash feature/add-model
git commit -m "feat: add ML model training pipeline" 

# When two branches modify the same lines, Git can't auto-merge
git merge feature/update-model
# CONFLICT (content): Merge conflict in src/model.py

# Open the file — Git marks conflicts like this:
# <<<<<<< HEAD
# model = RandomForestClassifier(n_estimators=100)
# =======
# model = XGBClassifier(n_estimators=200, learning_rate=0.1)
# >>>>>>> feature/update-model

# To resolve:
# 1. Edit the file — keep what you want, remove markers
# 2. Stage the resolved file
git add src/model.py
# 3. Complete the merge
git commit -m "merge: resolve model selection conflict, keep XGBoost"

# Abort a merge if things go wrong
git merge --abort

# Branch naming conventions:
# feature/   — new functionality
# fix/       — bug fixes
# experiment/— DS experiments (may be thrown away)
# hotfix/    — urgent production fixes
# docs/      — documentation updates

# Example: Data Science experiment workflow
git switch -c experiment/lstm-vs-transformer

# ... do your work, commit results ...
git add notebooks/lstm_experiment.ipynb
git commit -m "experiment: LSTM achieves 0.87 F1"

git add notebooks/transformer_experiment.ipynb
git commit -m "experiment: Transformer achieves 0.92 F1"

# Winner! Merge back
git switch main
git merge experiment/lstm-vs-transformer
git branch -d experiment/lstm-vs-transformer

# Add a remote (usually called 'origin')
git remote add origin https://github.com/username/my-project.git

# View remotes
git remote -v

# Push your code to the remote
git push -u origin main    # -u sets up tracking (first time only)

# Subsequent pushes
git push

# Clone an existing repo
git clone https://github.com/username/project.git
git clone https://github.com/username/project.git my-local-name

# Clone only the latest snapshot (faster for large repos)
git clone --depth 1 https://github.com/username/project.git

# Fetch — download remote changes (doesn't modify your files)
git fetch origin

# See what changed on remote
git log origin/main --oneline -5

# Pull — fetch + merge (updates your files)
git pull origin main

# Pull with rebase (cleaner history)
git pull --rebase origin main

# If pull causes conflicts, resolve them then:
git add .
git rebase --continue   # if rebasing
# or
git commit              # if merging

# 1. Fork a repo on GitHub (click Fork button)

# 2. Clone YOUR fork
git clone https://github.com/YOUR-USERNAME/project.git
cd project

# 3. Add the original repo as 'upstream'
git remote add upstream https://github.com/ORIGINAL-OWNER/project.git

# 4. Keep your fork updated
git fetch upstream
git switch main
git merge upstream/main
git push origin main

# 5. Create a branch for your contribution
git switch -c fix/typo-in-readme

# 6. Make changes, commit, push to YOUR fork
git commit -am "fix: correct typo in installation instructions"
git push origin fix/typo-in-readme

# 7. Open a Pull Request on GitHub (from your fork to original)

# Install GitHub CLI: https://cli.github.com
# Authenticate
gh auth login

# Create a PR from current branch
gh pr create --title "feat: add feature engineering pipeline" \
             --body "## Changes
- Added outlier detection
- Added feature scaling
- Added polynomial features

## Testing
- Unit tests pass
- Tested on sample dataset"

# Create a draft PR (not ready for review yet)
gh pr create --draft --title "WIP: experiment with LSTM model"

# List open PRs
gh pr list

# View PR details
gh pr view 42

# Check out someone's PR locally for testing
gh pr checkout 42

# View PR diff
gh pr diff 42

# Add a review comment
gh pr review 42 --comment --body "Looks good, but please add docstrings to the new functions"

# Approve a PR
gh pr review 42 --approve --body "LGTM! Great work on the preprocessing pipeline"

# Request changes
gh pr review 42 --request-changes --body "Please add error handling for missing columns"

# Merge a PR
gh pr merge 42 --merge    # regular merge commit
gh pr merge 42 --squash   # squash all commits into one
gh pr merge 42 --rebase   # rebase onto main

# Good PR structure for DS projects:

# 1. Small, focused PRs (not 2000-line monsters)
# ✗ "Add entire ML pipeline" (1500 lines)
# ✓ "Add data preprocessing" → "Add model training" → "Add evaluation"

# 2. Clear description with context
# - What does this PR do?
# - Why is this change needed?
# - How was it tested?
# - Any metrics/results?

# 3. Include results for model changes
# "Model accuracy: 0.85 → 0.92 (+7pp)
#  F1 score: 0.82 → 0.89
#  Tested on holdout set (n=5,000)"

# 4. Don't include notebooks with outputs in PR
#   (outputs make diffs unreadable)
#   Clear outputs before committing:
jupyter nbconvert --clear-output --inplace notebook.ipynb

# .gitignore for Data Science projects

# ─── Data files ─────────────────────────────
*.csv
*.tsv
*.parquet
*.feather
*.h5
*.hdf5
*.sqlite
*.db
data/raw/
data/processed/
data/external/

# ─── Model artifacts ────────────────────────
*.pkl
*.pickle
*.joblib
*.pt
*.pth
*.h5
*.onnx
*.pmml
models/

# ─── Notebooks ──────────────────────────────
.ipynb_checkpoints/
*/.ipynb_checkpoints/

# ─── Python ─────────────────────────────────
__pycache__/
*.py[cod]
*.egg-info/
dist/
build/
.eggs/
*.so

# ─── Environments ───────────────────────────
.env
.venv/
venv/
env/
*.env.local

# ─── IDE ────────────────────────────────────
.vscode/
.idea/
*.swp
*.swo
*~

# ─── OS ─────────────────────────────────────
.DS_Store
Thumbs.db
desktop.ini

# ─── Logs & temp ────────────────────────────
*.log
logs/
tmp/
.cache/
wandb/
mlruns/

# Ignore everything in a directory, but keep the directory
data/raw/*
!data/raw/.gitkeep

# Ignore all CSVs except a specific one
*.csv
!reference_data.csv

# Ignore files only in root (not subdirectories)
/config.local.py

# Ignore by directory depth
**/logs/       # ignore 'logs' at any depth
debug/         # ignore 'debug' only at root

# Negate a pattern (un-ignore)
*.h5
!models/production_model.h5

# Check what's ignored
git status --ignored

# Check if a specific file is ignored
git check-ignore -v data/train.csv

# Oops! You committed a large CSV file
# Remove from Git tracking (keep the file locally)
git rm --cached data/large_dataset.csv
echo "data/large_dataset.csv" >> .gitignore
git add .gitignore
git commit -m "chore: remove large CSV from tracking, add to gitignore"

# Remove an entire directory from tracking
git rm -r --cached __pycache__/
git commit -m "chore: remove pycache from tracking"

# Nuclear option: remove file from ALL history (if it contained secrets)
# WARNING: rewrites history, coordinate with team!
git filter-branch --force --index-filter \
  'git rm --cached --ignore-unmatch secrets.env' \
  --prune-empty -- --all

# Better tool for history rewriting:
# pip install git-filter-repo
# git filter-repo --invert-paths --path secrets.env

# Save current changes to stash
git stash

# Save with a description
git stash push -m "WIP: feature engineering experiments"

# List all stashes
git stash list
# stash@{0}: On feature/model: WIP: feature engineering experiments
# stash@{1}: On main: quick debug session

# Apply most recent stash (keep it in stash list)
git stash apply

# Apply and remove from stash list
git stash pop

# Apply a specific stash
git stash apply stash@{1}

# Remove a specific stash
git stash drop stash@{0}

# Clear all stashes
git stash clear

# Stash including untracked files
git stash push -u -m "WIP: including new files"

# Stash only specific files
git stash push -m "stash only model.py" -- src/model.py

# View what's in a stash
git stash show stash@{0}         # summary
git stash show -p stash@{0}      # full diff

# Create a branch from a stash
git stash branch new-feature stash@{0}

# Common workflow: quick context switch
# You're working on feature A, need to fix urgent bug
git stash push -m "WIP: feature A halfway done"
git switch main
git switch -c hotfix/urgent-bug
# ... fix the bug, commit, merge ...
git switch feature-a
git stash pop  # back to where you were!

# Lightweight tag (just a pointer)
git tag v1.0.0

# Annotated tag (recommended — includes message, author, date)
git tag -a v1.0.0 -m "First production release"

# Tag a past commit
git tag -a v0.9.0 -m "Beta release" abc1234

# List tags
git tag
git tag -l "v1.*"    # filter by pattern

# View tag details
git show v1.0.0

# Push tags to remote
git push origin v1.0.0      # push one tag
git push origin --tags       # push all tags

# Delete a tag
git tag -d v0.1.0            # local
git push origin --delete v0.1.0  # remote

# Semantic Versioning: MAJOR.MINOR.PATCH
# MAJOR — breaking changes (new model architecture, API change)
# MINOR — new features (added endpoint, new feature engineering)
# PATCH — bug fixes (fixed preprocessing bug, typo)

# ML-specific versioning strategy:
# v1.0.0 — first production model
# v1.1.0 — added new features to model
# v1.1.1 — fixed data preprocessing bug
# v2.0.0 — switched from RF to XGBoost (different model)

# Tag with model metrics
git tag -a v2.1.0 -m "XGBoost v2.1
Accuracy: 0.94
F1: 0.91
AUC: 0.97
Training data: 2024-01-01 to 2024-06-30
Features: 47 (added 5 new interaction features)"

# Create a GitHub release (includes downloadable assets)
gh release create v2.1.0 --title "Model v2.1.0" \
  --notes "Improved model with 5 new interaction features.
  Accuracy: 0.94 (+2pp vs v2.0.0)"

# Instead of merging main into your branch (creates merge commit):
git switch feature/model
git merge main  # creates a merge commit

# Rebase puts your commits on TOP of main (linear history):
git switch feature/model
git rebase main

# After rebase, your branch looks like:
# main: A—B—C
# feature:     D—E—F  (your commits replayed on top of C)

# If conflicts occur during rebase:
git add resolved_file.py
git rebase --continue

# Abort if things go wrong
git rebase --abort

# Clean up last 4 commits before creating a PR
git rebase -i HEAD~4

# Opens editor with:
# pick abc1234 WIP: start model training
# pick def5678 fix typo
# pick ghi9012 more work on training
# pick jkl3456 finish model training

# Change to:
# pick abc1234 WIP: start model training
# squash def5678 fix typo              ← merge into previous
# squash ghi9012 more work on training ← merge into previous
# reword jkl3456 finish model training ← change message

# Commands:
# pick   — keep the commit as is
# squash — merge into previous commit
# fixup  — like squash but discard this commit's message
# reword — keep commit, edit message
# edit   — pause to amend the commit
# drop   — delete the commit

# NEVER rebase commits that have been pushed and shared with others!
# Rebase rewrites history — this will cause problems for collaborators

# Safe: rebase your LOCAL commits before pushing
git switch feature/my-work
git rebase main        # OK — only your local commits
git push               # push clean history

# DANGEROUS: rebase after pushing
git push origin feature/my-work
git rebase main        # Rewrites already-pushed commits!
git push --force       # Forces overwrite — breaks collaborators!

# If you must update after push, use merge instead:
git switch feature/my-work
git merge main         # Safe even after pushing

# Jupyter notebooks (.ipynb) are JSON — diffs are messy:
# - Cell outputs (images, tables) bloat the repo
# - Execution counts change on every run
# - Cell metadata changes randomly
# - Merge conflicts are nearly impossible to resolve

# Solution 1: Clear outputs before committing
jupyter nbconvert --clear-output --inplace notebook.ipynb
git add notebook.ipynb
git commit -m "feat: add EDA notebook (outputs cleared)"

# Solution 2: Automate with pre-commit hook
# .pre-commit-config.yaml
# repos:
#   - repo: https://github.com/kynan/nbstripout
#     hooks:
#       - id: nbstripout

# Solution 3: Install nbstripout globally for a repo
pip install nbstripout
nbstripout --install         # adds Git filter
# Now outputs are automatically stripped on commit!

# Install nbdime for human-readable notebook diffs
pip install nbdime

# Configure Git to use nbdime
nbdime config-git --enable --global

# Now 'git diff' shows notebook changes in a readable format
git diff notebook.ipynb
# Instead of raw JSON, you see:
# Cell 3 (code):
# -  model = RandomForestClassifier()
# +  model = XGBClassifier(n_estimators=200)

# Visual diff tool (opens in browser)
nbdime diff notebook_v1.ipynb notebook_v2.ipynb

# Merge tool for notebooks
nbdime merge base.ipynb local.ipynb remote.ipynb

# Use jupytext to sync .ipynb with .py files
pip install jupytext

# Convert notebook to Python script
jupytext --to py:percent notebook.ipynb
# Creates notebook.py with # %% cell markers

# Sync both formats (edit either one)
jupytext --set-formats ipynb,py:percent notebook.ipynb

# In .gitignore, you can then ignore .ipynb and only track .py:
# *.ipynb    ← ignore notebooks
# !*.py      ← track Python scripts

# Or track both but strip outputs from .ipynb:
# Use nbstripout for .ipynb
# Track .py as the "source of truth" 

# Hooks live in .git/hooks/ (local, not shared by default)
# Use pre-commit framework to share hooks with team

# Install pre-commit
pip install pre-commit

# Create .pre-commit-config.yaml in repo root
cat > .pre-commit-config.yaml << 'EOF'
repos:
  # Code formatting
  - repo: https://github.com/psf/black
    rev: 24.1.0
    hooks:
      - id: black
        language_version: python3

  # Import sorting
  - repo: https://github.com/pycqa/isort
    rev: 5.13.2
    hooks:
      - id: isort

  # Linting
  - repo: https://github.com/pycqa/flake8
    rev: 7.0.0
    hooks:
      - id: flake8
        args: [--max-line-length=120]

  # Strip notebook outputs
  - repo: https://github.com/kynan/nbstripout
    rev: 0.7.1
    hooks:
      - id: nbstripout

  # Check for secrets
  - repo: https://github.com/Yelp/detect-secrets
    rev: v1.4.0
    hooks:
      - id: detect-secrets
EOF

# Install the hooks
pre-commit install

# Now these checks run automatically before every commit!
# To run manually on all files:
pre-commit run --all-files

# Create a custom hook that checks for large files
cat > .git/hooks/pre-commit << 'HOOK'
#!/bin/bash
# Prevent commits with files larger than 5MB

MAX_SIZE=5242880  # 5MB in bytes
EXIT_CODE=0

for file in $(git diff --cached --name-only); do
    if [ -f "$file" ]; then
        size=$(wc -c < "$file")
        if [ "$size" -gt "$MAX_SIZE" ]; then
            echo "ERROR: $file is $(($size/1048576))MB (max 5MB)"
            echo "  Use Git LFS for large files: git lfs track '$file'"
            EXIT_CODE=1
        fi
    fi
done

exit $EXIT_CODE
HOOK

chmod +x .git/hooks/pre-commit

# Install Git LFS
git lfs install

# Track specific file types
git lfs track "*.csv"
git lfs track "*.parquet"
git lfs track "*.pkl"
git lfs track "*.pt"
git lfs track "*.h5"
git lfs track "data/**"

# This creates/updates .gitattributes
cat .gitattributes
# *.csv filter=lfs diff=lfs merge=lfs -text
# *.parquet filter=lfs diff=lfs merge=lfs -text

# IMPORTANT: commit .gitattributes first!
git add .gitattributes
git commit -m "chore: configure Git LFS for data and model files"

# Now add large files normally — LFS handles them
git add data/training_set.csv
git commit -m "data: add training dataset"
git push

# List tracked LFS patterns
git lfs track

# List actual LFS files in repo
git lfs ls-files

# Check LFS storage usage
git lfs env

# Pull LFS files (after clone)
git lfs pull

# Clone without downloading LFS files (faster)
GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/user/project.git

# Download LFS files for specific patterns only
git lfs pull --include="data/train*"
git lfs pull --exclude="models/"

# Migrate existing files to LFS
git lfs migrate import --include="*.csv" --everything

# Copy a specific commit from another branch
git cherry-pick abc1234

# Cherry-pick without committing (stage changes only)
git cherry-pick --no-commit abc1234

# Cherry-pick a range of commits
git cherry-pick abc1234..def5678

# Use case: backport a bug fix from development to production
git switch production
git cherry-pick abc1234  # the fix commit from dev branch
git push

# If conflicts occur
git cherry-pick --continue  # after resolving
git cherry-pick --abort     # to cancel

# Binary search through history to find which commit broke something
git bisect start

# Mark current commit as bad (bug is present)
git bisect bad

# Mark a known good commit (bug was NOT present)
git bisect good v1.0.0

# Git checks out a middle commit — test it!
# If the bug is present:
git bisect bad
# If the bug is NOT present:
git bisect good

# Repeat until Git finds the exact commit
# "abc1234 is the first bad commit"

# Done — go back to normal
git bisect reset

# Automated bisect with a test script:
git bisect start HEAD v1.0.0
git bisect run python -m pytest tests/test_model.py -x
# Git automatically finds the first failing commit!

# Reflog tracks every HEAD movement — your safety net!
git reflog
# abc1234 HEAD@{0}: commit: add feature
# def5678 HEAD@{1}: checkout: moving from main to feature
# ghi9012 HEAD@{2}: commit: initial commit

# Accidentally deleted a branch? Recover it!
git branch -D important-branch  # oops!
git reflog  # find the last commit on that branch
git branch important-branch HEAD@{3}  # recovered!

# Accidentally ran git reset --hard? Recover!
git reset --hard HEAD~5  # oops, lost 5 commits!
git reflog  # find where HEAD was before
git reset --hard HEAD@{1}  # back to before the reset!

# Reflog entries expire after 90 days (default)
# Check expiry:
git config gc.reflogExpire

# GitHub Flow — simple and effective
# Rules:
# 1. main is always deployable
# 2. Create feature branches from main
# 3. Open PRs for review
# 4. Merge to main after approval
# 5. Deploy from main

# Workflow:
git switch main
git pull
git switch -c feature/add-prediction-endpoint

# Work, commit, push
git commit -am "feat: add /predict endpoint"
git push -u origin feature/add-prediction-endpoint

# Create PR → Review → Merge → Delete branch
gh pr create
# After merge:
git switch main
git pull
git branch -d feature/add-prediction-endpoint

# Git Flow — more structured, good for versioned software
# Branches:
# main     — production releases only
# develop  — integration branch
# feature/ — new features (branch from develop)
# release/ — preparing a release (branch from develop)
# hotfix/  — urgent fixes (branch from main)

# Start a feature
git switch develop
git switch -c feature/new-model

# Finish feature — merge back to develop
git switch develop
git merge --no-ff feature/new-model
git branch -d feature/new-model

# Prepare release
git switch -c release/v2.0.0
# ... final testing, version bumps ...
git switch main
git merge --no-ff release/v2.0.0
git tag -a v2.0.0 -m "Release v2.0.0"
git switch develop
git merge --no-ff release/v2.0.0
git branch -d release/v2.0.0

# Trunk-based — everyone commits to main (or very short-lived branches)
# Rules:
# 1. Small, frequent commits to main
# 2. Feature flags instead of long-lived branches
# 3. Branches live < 1 day
# 4. CI/CD runs on every commit

# Short-lived branch (< 1 day)
git switch -c fix/null-check
git commit -am "fix: handle null values in preprocessing"
git push -u origin fix/null-check
gh pr create
# Get quick review, merge same day

# Feature flags for larger features
# In code:
# if feature_flags.is_enabled("new_model_v2"):
#     prediction = new_model.predict(features)
# else:
#     prediction = old_model.predict(features)

# .github/workflows/ci.yml
name: CI Pipeline

on:
  push:
    branches: [main]
  pull_request:
    branches: [main]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: |
          pip install -r requirements.txt
          pip install pytest flake8

      - name: Lint
        run: flake8 src/ --max-line-length=120

      - name: Run tests
        run: pytest tests/ -v --tb=short

# .github/workflows/model-validation.yml
name: Model Validation

on:
  pull_request:
    paths:
      - 'src/model/**'
      - 'configs/**'

jobs:
  validate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: pip install -r requirements.txt

      - name: Train on test data
        run: python src/model/train.py --config configs/test.yaml

      - name: Validate metrics
        run: |
          python -c "
          import json
          with open('results/metrics.json') as f:
              m = json.load(f)
          assert m['accuracy'] > 0.85, f'Accuracy {m["accuracy"]} below threshold'
          assert m['f1'] > 0.80, f'F1 {m["f1"]} below threshold'
          print('Model validation passed!')
          print(f'Accuracy: {m["accuracy"]:.4f}')
          print(f'F1: {m["f1"]:.4f}')
          " 

# .github/workflows/daily-data.yml
name: Daily Data Collection

on:
  schedule:
    - cron: '0 6 * * *'  # Run at 6 AM UTC daily
  workflow_dispatch:       # Allow manual trigger

jobs:
  collect:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: '3.11'

      - name: Install dependencies
        run: pip install -r requirements.txt

      - name: Collect data
        env:
          API_KEY: ${{ secrets.DATA_API_KEY }}
        run: python scripts/collect_daily_data.py

      - name: Commit new data
        run: |
          git config user.name "GitHub Actions"
          git config user.email "actions@github.com"
          git add data/daily/
          git diff --staged --quiet || git commit -m "data: daily collection $(date +%Y-%m-%d)"
          git push

# Morning: start fresh
git switch main
git pull origin main
git switch -c feature/todays-work

# During the day: small, frequent commits
git add src/module.py
git commit -m "feat: add data validation step"

# End of day: push your work
git push -u origin feature/todays-work

# Ready for review: create PR
gh pr create --title "feat: add data validation"

# After PR is merged: clean up
git switch main
git pull
git branch -d feature/todays-work

# Mistake: committed to wrong branch
git switch correct-branch
git cherry-pick abc1234    # bring commit to correct branch
git switch wrong-branch
git reset HEAD~1           # remove from wrong branch

# Mistake: typo in last commit message
git commit --amend -m "correct message here"

# Mistake: forgot to add a file to last commit
git add forgotten_file.py
git commit --amend --no-edit

# Mistake: committed sensitive data
git reset --soft HEAD~1    # undo commit, keep changes staged
# remove the sensitive data, then recommit

# Mistake: git pull created ugly merge commits
git reset --hard HEAD~1    # undo the merge
git pull --rebase          # replay your commits on top

# Mistake: need to undo a pushed commit (safely)
git revert abc123         # creates a new "undo" commit
git push

# Add these to your ~/.gitconfig [alias] section:
git config --global alias.st "status --short"
git config --global alias.co "checkout"
git config --global alias.sw "switch"
git config --global alias.br "branch"
git config --global alias.ci "commit"
git config --global alias.lg "log --oneline --graph --all -20"
git config --global alias.last "log -1 HEAD --stat"
git config --global alias.unstage "restore --staged"
git config --global alias.undo "reset HEAD~1"
git config --global alias.amend "commit --amend --no-edit"
git config --global alias.wip "commit -am 'WIP: work in progress'"

# Usage:
# git st          → short status
# git lg          → pretty graph log
# git last        → last commit details
# git unstage f   → unstage a file
# git undo        → undo last commit (keep changes)
# git amend       → add to last commit
# git wip         → quick WIP commit

# ┌─────────────────────┬────────────────────────────────────┐
# │ Action               │ Command                            │
# ├─────────────────────┼────────────────────────────────────┤
# │ Init repo            │ git init                           │
# │ Clone repo           │ git clone <url>                    │
# │ Stage files          │ git add <files>                    │
# │ Commit               │ git commit -m "msg"                │
# │ Push                 │ git push origin <branch>           │
# │ Pull                 │ git pull origin <branch>           │
# │ Status               │ git status                         │
# │ Log                  │ git log --oneline                  │
# │ Diff                 │ git diff                           │
# │ Create branch        │ git switch -c <name>               │
# │ Switch branch        │ git switch <name>                  │
# │ Merge                │ git merge <branch>                 │
# │ Rebase               │ git rebase <branch>                │
# │ Stash                │ git stash push -m "msg"            │
# │ Tag                  │ git tag -a v1.0 -m "msg"           │
# │ Cherry-pick          │ git cherry-pick <hash>             │
# │ Bisect               │ git bisect start                   │
# │ Undo last commit     │ git reset HEAD~1                   │
# │ Revert commit        │ git revert <hash>                  │
# │ Recover lost work    │ git reflog                         │
# └─────────────────────┴────────────────────────────────────┘
echo "Bookmark this cheat sheet!"