1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Simple GET request
http GET https://api.github.com/users/stonecharioteer

# POST with JSON data
http POST https://httpbin.org/post name=John age:=30 active:=true

# Authentication
http GET https://api.github.com/user Authorization:"token YOUR_TOKEN"

# File uploads
http --form POST https://httpbin.org/post [email protected]

# Custom headers and cookies
http GET https://example.com X-Custom-Header:value Cookie:session=abc123

# Pretty-print JSON responses (default)
http GET https://api.github.com/repos/python/cpython | jq '.stargazers_count'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Install fzf
git clone --depth 1 https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install

# Basic file search
fzf

# Search command history
history | fzf

# Search and edit files
vim $(find . -type f | fzf)

# Git integration
git log --oneline | fzf

# Process search and kill
ps aux | fzf | awk '{print $2}' | xargs kill

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# Add to .bashrc or .zshrc for enhanced functionality

# Better cd with fuzzy search
cdf() {
    local dir
    dir=$(find ${1:-.} -path '*/\.*' -prune \
          -o -type d -print 2> /dev/null | fzf +m) &&
    cd "$dir"
}

# Fuzzy git branch checkout
fgb() {
    local branches branch
    branches=$(git branch -vv) &&
    branch=$(echo "$branches" | fzf +m) &&
    git checkout $(echo "$branch" | awk '{print $1}' | sed "s/.* //")
}

# Fuzzy kill process
fkill() {
    local pid
    pid=$(ps -ef | sed 1d | fzf -m | awk '{print $2}')
    if [ "x$pid" != "x" ]; then
        echo $pid | xargs kill -${1:-9}
    fi
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Install bat
cargo install bat
# or
brew install bat

# Basic usage with syntax highlighting
bat main.py

# Show line numbers and git changes
bat --number --show-all src/app.rs

# Use as pager replacement
export PAGER="bat --plain --paging=always"

# Combine with other tools
curl -s https://raw.githubusercontent.com/rust-lang/rust/master/README.md | bat -l md

# Configuration file
bat --config-file

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Basic search
rg "TODO"

# Case insensitive search
rg -i "error"

# Search in specific file types
rg "function" --type py
rg "impl" --type rust

# Search with context lines
rg "error" -C 3

# Regular expressions
rg "fn\s+\w+\(" --type rust

# Exclude directories
rg "pattern" --glob '!target/' --glob '!node_modules/'

# Replace mode (preview)
rg "old_function" --replace "new_function" --type py

# JSON output for scripting
rg "pattern" --json | jq '.data.lines.text'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Python 3 (current)
python -m http.server 8000

# Python 2 (legacy)
python -m SimpleHTTPServer 8000

# Serve specific directory
python -m http.server 8000 --directory /path/to/files

# Bind to specific interface
python -m http.server 8000 --bind 127.0.0.1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Install globally
npm install -g live-server

# Serve current directory with live reload
live-server

# Custom port and browser
live-server --port=3000 --browser=firefox

# Serve specific directory
live-server --root=./dist

# Proxy API requests
live-server --proxy=/api:http://localhost:3000

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# .pre-commit-config.yaml
repos:
  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.4.0
    hooks:
      - id: trailing-whitespace
      - id: end-of-file-fixer
      - id: check-yaml
      - id: check-added-large-files

  - repo: https://github.com/psf/black
    rev: 22.10.0
    hooks:
      - id: black
        language_version: python3

  - repo: https://github.com/pycqa/flake8
    rev: 5.0.4
    hooks:
      - id: flake8

  - repo: https://github.com/pycqa/isort
    rev: 5.10.1
    hooks:
      - id: isort
        args: ["--profile", "black"]

1
2
3
4
5
6
7
8
9

# Install and setup
pip install pre-commit
pre-commit install

# Run on all files
pre-commit run --all-files

# Update hook versions
pre-commit autoupdate

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Install cookiecutter
pip install cookiecutter

# Create project from template
cookiecutter https://github.com/cookiecutter/cookiecutter-django

# Use local template
cookiecutter /path/to/my-template

# Create custom template structure
my-template/
├── cookiecutter.json
├── {{cookiecutter.project_name}}/
│   ├── README.md
│   ├── setup.py
│   └── {{cookiecutter.module_name}}/
│       └── __init__.py

1
2
3
4
5
6
7

{
  "project_name": "My Project",
  "module_name": "{{ cookiecutter.project_name.lower().replace(' ', '_') }}",
  "author_name": "Your Name",
  "version": "0.1.0",
  "license": ["MIT", "BSD", "GPL"]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# Install
pip install youtube-dl

# Basic download
youtube-dl "https://www.youtube.com/watch?v=VIDEO_ID"

# Download audio only
youtube-dl -x --audio-format mp3 "URL"

# Download best quality
youtube-dl -f "best[height<=720]" "URL"

# Download playlist
youtube-dl -i "PLAYLIST_URL"

# Extract metadata
youtube-dl --get-title --get-duration "URL"

# Custom filename format
youtube-dl -o "%(uploader)s - %(title)s.%(ext)s" "URL"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

# Install
brew install cloc
# or
sudo apt install cloc

# Count lines in current directory
cloc .

# Specific languages
cloc --include-lang=Python,JavaScript .

# Exclude directories
cloc --exclude-dir=node_modules,target .

# Compare two codebases
cloc --diff version1/ version2/

# Output formats
cloc --json .
cloc --csv .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Install
cargo install tokei

# Basic usage
tokei

# Specific languages
tokei --languages rust,python

# Sort by lines
tokei --sort lines

# Output formats
tokei --output json
tokei --output yaml

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

from fastapi import FastAPI, HTTPException, Depends
from pydantic import BaseModel
from typing import List, Optional
import asyncio

app = FastAPI(title="Modern API", version="1.0.0")

class User(BaseModel):
    id: int
    name: str
    email: str
    is_active: bool = True

class UserCreate(BaseModel):
    name: str
    email: str

# Async endpoint with automatic OpenAPI documentation
@app.get("/users/{user_id}", response_model=User)
async def get_user(user_id: int):
    if user_id < 1:
        raise HTTPException(status_code=404, detail="User not found")

    # Simulate async database call
    await asyncio.sleep(0.1)
    return User(id=user_id, name="John Doe", email="[email protected]")

@app.post("/users/", response_model=User)
async def create_user(user: UserCreate):
    # Auto-validation from Pydantic model
    new_user = User(id=123, **user.dict())
    return new_user

# Dependency injection
async def get_current_user() -> User:
    return User(id=1, name="Current User", email="[email protected]")

@app.get("/me", response_model=User)
async def read_users_me(current_user: User = Depends(get_current_user)):
    return current_user

# Run with: uvicorn main:app --reload

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

package controllers

import (
    "github.com/revel/revel"
)

type App struct {
    *revel.Controller
}

func (c App) Index() revel.Result {
    return c.Render()
}

func (c App) Hello(myName string) revel.Result {
    c.Viewargs["name"] = myName
    return c.Render()
}

// Routes (conf/routes)
// GET     /                                       App.Index
// GET     /hello/:myName                          App.Hello

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Install
pip install bandit

# Scan current directory
bandit -r .

# Skip test files
bandit -r . --skip B101

# Output formats
bandit -r . -f json
bandit -r . -f html -o security-report.html

# Configuration file
bandit -r . -c bandit.conf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

import responses
import requests

@responses.activate
def test_api_call():
    # Mock the API response
    responses.add(
        responses.GET,
        "https://api.example.com/users/1",
        json={"id": 1, "name": "John Doe"},
        status=200
    )

    # Make the request
    resp = requests.get("https://api.example.com/users/1")

    # Test the response
    assert resp.status_code == 200
    assert resp.json()["name"] == "John Doe"

# Dynamic responses
@responses.activate
def test_dynamic_response():
    def request_callback(request):
        return (200, {}, '{"dynamic": "response"}')

    responses.add_callback(
        responses.GET,
        "https://api.example.com/dynamic",
        callback=request_callback
    )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Create aliases for gradual adoption
alias cat='bat'
alias grep='rg'
alias find='fd'  # fd is another excellent Rust-based find replacement

# Add to .bashrc/.zshrc
export PAGER="bat --plain --paging=always"

# Customize fzf key bindings
export FZF_DEFAULT_COMMAND='rg --files'
export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"