Modern tooling

import subprocess
import sys
import tempfile
from pathlib import Path


def build_wheel_with_hatchling(project_dir: str) -> str:
    """Build a wheel using hatchling and return the wheel file path."""
    project_path = Path(project_dir)

    # Simulate a minimal project structure if missing
    if not (project_path /…

import mock

bugsnag = mock.MagicMock()

def notify_error(message, severity="error"):
    bugsnag.notify(message, severity=severity)

if __name__ == "__main__":
    notify_error("Test error", severity="warning")
    bugsnag.notify.assert_called_once_with("Test error", severity="warning")
    print("Mocked BugSnag noti…

import sys
import argparse


def do_greet(args):
    print(f"Hello, {args.name}!")


def do_goodbye(args):
    print(f"Goodbye, {args.name}!")


def main():
    parser = argparse.ArgumentParser(prog="clickapp")
    subparsers = parser.add_subparsers(dest="command", required=True)

    greet_parser = subparsers.add_par…

import subprocess
from unittest.mock import patch, MagicMock


def bump_version(current_version: str, increment: str = "patch") -> str:
    """Simulate commitizen's version bump logic."""
    major, minor, patch = map(int, current_version.split("."))
    if increment == "major":
        major += 1
        minor = 0
  …

import subprocess
import sys

# Mock twine upload to TestPyPI using subprocess dry-run
def mock_twine_upload(dist_file: str, repo_url: str = "https://test.pypi.org/legacy/") -> None:
    """Simulate twine upload by checking dist file and printing intended action."""
    if not dist_file.endswith((".whl", ".tar.gz")):
…

import os
import shutil
import subprocess
import sys
import tempfile
from pathlib import Path

def uv_pip_sync_fast_install_mock(requirements_text: str) -> dict:
    """Simulate a fast uv pip sync by mocking file operations and subprocess calls."""
    mock_dir = Path(tempfile.mkdtemp(prefix="uv_mock_"))
    req_lines…

import json
from unittest.mock import Mock

# Simulate a PEP 517 backend interface
class Pep517Backend:
    def build_wheel(self, wheel_directory, config_settings=None, metadata_directory=None):
        return f"{wheel_directory}/mock_package-1.0.0-py3-none-any.whl"

    def get_requires_for_build_wheel(self, config_s…

import subprocess
import sys


def install_with_pipx(tool_name: str) -> str:
    """
    Mock a pipx install step by validating the tool name and
    simulating the installation command output.
    """
    allowed_tools = {"black", "flake8", "mypy", "ruff"}
    if tool_name not in allowed_tools:
        raise ValueErr…

```python
from unittest.mock import patch

def get_version_from_scm():
    try:
        import setuptools_scm
        return setuptools_scm.get_version()
    except (ImportError, LookupError):
        return None

if __name__ == "__main__":
    with patch("setuptools_scm.get_version", return_value="1.2.3"):
        pr…

import subprocess
from unittest.mock import Mock, patch

def run_black_formatter(file_path: str, check_only: bool = False) -> dict:
    """Run black formatter on a file via subprocess."""
    cmd = ["black", "--check" if check_only else "-", file_path]
    result = subprocess.run(cmd, capture_output=True, text=True)
 …

from typing import TypedDict, Callable


class User(TypedDict):
    id: int
    name: str


def get_user_name(user_id: int, get_user: Callable[[int], User]) -> str:
    user = get_user(user_id)
    return user["name"]


def mock_get_user(user_id: int) -> User:
    return {"id": user_id, "name": f"User {user_id}"}


if…

import json
from pathlib import Path
from typing import Any, Callable


def validate_data(
    data: dict[str, Any],
    rules: dict[str, Callable[[Any], bool]],
    path: Path | None = None,
) -> bool:
    """Validate a dict against a set of simple rules."""
    all_valid = True
    for field, validator in rules.item…