Папка scripts в Python: структура и употребление

Расширенные примеры

Пример 1: Скрипт миграции БД с аргументами и интерактивным подтверждением

Скрипт scripts/migrate.py позволяет указать направление миграции (up/down) и номер версии.

#!/usr/bin/env python3
"""Database migration script."""
import argparse
import sys
from myapp.database import get_migrations, apply_migration, revert_migration

def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("action", choices=["up", "down"], help="Migration direction")
    parser.add_argument("--version", type=int, default=None, help="Target version")
    parser.add_argument("--force", action="store_true", help="Skip confirmation")
    return parser.parse_args()

def confirm():
    answer = input("Apply migration? (y/n): ").strip().lower()
    return answer in ("y", "yes")

def main():
    args = parse_args()
    migrations = get_migrations()
    if args.version is None:
        args.version = len(migrations) if args.action == "up" else 0

    if not args.force:
        print(f"About to apply {args.action} to version {args.version}")
        if not confirm():
            print("Cancelled.")
            sys.exit(0)

    try:
        if args.action == "up":
            apply_migration(version=args.version, migrations=migrations)
        else:
            revert_migration(version=args.version, migrations=migrations)
        print("Migration successful.")
    except Exception as exc:
        print(f"Migration failed: {exc}", file=sys.stderr)
        sys.exit(1)

if __name__ == "__main__":
    main()

Результат запуска без --force:

$ python scripts/migrate.py up --version 3
About to apply up to version 3
Apply migration? (y/n): y
Migration successful.

Пример 2: Docker healthcheck скрипт на Python

Проверяет доступность HTTP-эндпоинта и возвращает 0/1.

#!/usr/bin/env python3
"""Healthcheck script for Docker container."""
import http.client
import os
import sys

def main():
    host = os.getenv("HEALTHCHECK_HOST", "localhost")
    port = int(os.getenv("HEALTHCHECK_PORT", 5000))
    endpoint = os.getenv("HEALTHCHECK_PATH", "/health")

    conn = http.client.HTTPConnection(host, port, timeout=5)
    try:
        conn.request("GET", endpoint)
        response = conn.getresponse()
        if response.status == 200:
            print("Healthcheck passed.")
            sys.exit(0)
        else:
            print(f"Healthcheck failed: HTTP {response.status}")
            sys.exit(1)
    except Exception as exc:
        print(f"Healthcheck error: {exc}")
        sys.exit(1)
    finally:
        conn.close()

if __name__ == "__main__":
    main()

В Dockerfile:

HEALTHCHECK --interval=30s --timeout=5s --retries=3 CMD ["python", "scripts/healthcheck.py"]

Пример 3: Скрипт пакетного выполнения с протоколированием в файл

Выполняет несколько команд (например, сборку статики, миграцию, тесты) и пишет лог в файл.

#!/usr/bin/env python3
"""CI pipeline script."""
import logging
import subprocess
import sys
from datetime import datetime

def setup_logger(log_file="build.log"):
    logging.basicConfig(
        level=logging.INFO,
        format="%(asctime)s %(levelname)s: %(message)s",
        handlers=[
            logging.FileHandler(log_file),
            logging.StreamHandler(sys.stdout)
        ]
    )
    return logging.getLogger(__name__)

def run_step(command, label, logger):
    logger.info("Starting step: %s", label)
    result = subprocess.run(command, capture_output=True, text=True)
    if result.returncode != 0:
        logger.error("Step '%s' failed with code %d", label, result.returncode)
        logger.error("STDERR: %s", result.stderr)
        sys.exit(result.returncode)
    logger.info("Step '%s' completed successfully.", label)
    for line in result.stdout.split("\n"):
        if line.strip():
            logger.debug("  %s", line)

def main():
    logger = setup_logger()
    logger.info("Pipeline started at %s", datetime.now().isoformat())

    steps = [
        (["python", "-m", "pip", "install", "-r", "requirements-dev.txt"], "Install dev deps"),
        (["python", "-m", "flake8", "myapp", "scripts"], "Lint"),
        (["python", "-m", "pytest", "tests/", "--verbose"], "Tests"),
        (["python", "scripts/migrate.py", "up"], "Database migration"),
    ]

    for cmd, label in steps:
        run_step(cmd, label, logger)

    logger.info("Pipeline finished successfully.")

if __name__ == "__main__":
    main()

Результат (фрагмент build.log):

2025-03-15 10:23:45,123 INFO: Pipeline started at 2025-03-15T10:23:45.123456
2025-03-15 10:23:45,567 INFO: Starting step: Install dev deps
2025-03-15 10:23:56,789 INFO: Step 'Install dev deps' completed successfully.
2025-03-15 10:23:57,012 INFO: Starting step: Lint
...

Пример 4: Скрипт генерации отчёта с использованием Jinja2

Читает данные из JSON, рендерит шаблон и сохраняет HTML.

#!/usr/bin/env python3
"""Generate report from data."""
import json
import sys
from pathlib import Path
from jinja2 import Environment, FileSystemLoader

def load_data(path: Path) -> dict:
    with open(path, "r", encoding="utf-8") as f:
        return json.load(f)

def render_report(data: dict, template_name: str) -> str:
    env = Environment(loader=FileSystemLoader("scripts/templates"))
    template = env.get_template(template_name)
    return template.render(data=data)

def main():
    if len(sys.argv) < 3:
        print("Usage: generate_report.py  ", file=sys.stderr)
        sys.exit(1)

    data_path = Path(sys.argv[1])
    output_path = Path(sys.argv[2])

    if not data_path.is_file():
        print(f"Data file not found: {data_path}", file=sys.stderr)
        sys.exit(1)

    data = load_data(data_path)
    html = render_report(data, "report.jinja2")

    output_path.parent.mkdir(parents=True, exist_ok=True)
    with open(output_path, "w", encoding="utf-8") as f:
        f.write(html)

    print(f"Report generated: {output_path}")

if __name__ == "__main__":
    main()

Шаблон scripts/templates/report.jinja2:

<!DOCTYPE html>
<html>
<head><title>Report</title></head>
<body>
<h1>Report for {{ data.title }}</h1>
<ul>
{% for item in data.items %}
    <li>{{ item.name }}: {{ item.value }}</li>
{% endfor %}
</ul>
</body>
</html>

Пример 5: Кроссплатформенный скрипт для запуска тестов с выбором окружения

#!/usr/bin/env python3
"""Run tests in different environments."""
import os
import platform
import subprocess
import sys

def get_venv_python():
    """Return python executable from active venv or system."""
    if hasattr(sys, "real_prefix") or (hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix):
        return sys.executable
    # Fallback
    return "python3" if platform.system() != "Windows" else "python"

def main():
    python = get_venv_python()
    print(f"Using Python: {python}")

    commands = [
        [python, "-m", "pytest", "--cov=myapp", "--cov-report=term-missing"],
        [python, "-m", "black", "--check", "myapp", "scripts"],
        [python, "-m", "isort", "--check", "myapp", "scripts"],
    ]

    for cmd in commands:
        print(f"Running: {' '.join(cmd)}")
        subprocess.run(cmd, check=True)

if __name__ == "__main__":
    main()

Результат на Linux:

Using Python: /home/user/project/.venv/bin/python3
Running: /home/user/project/.venv/bin/python3 -m pytest --cov=myapp --cov-report=term-missing
...
Running: /home/user/project/.venv/bin/python3 -m black --check myapp scripts
...
Running: /home/user/project/.venv/bin/python3 -m isort --check myapp scripts
...