numpy 2.5.1: pad

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify numpy.pad in pkg:pypi/numpy@2.5.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:pypi/numpy@2.5.1
Demonstrate these symbols/APIs:
  - numpy.pad

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:b1a34dea1285e2182ff4ffa5df91cf94c895e95016346c5b1bc17c9656d890eb","contract":["numpy.pad() with constant mode pads array with default and specified constant values.","numpy.pad() with edge mode extends boundary elements across specified pad widths.","numpy.pad() with linear_ramp mode creates a linear gradient between end_values and array edges.","numpy.pad() with reflect and symmetric modes reflects vector values without and with edge duplication.","numpy.pad() with wrap mode cyclically tiles array values along the specified axis.","numpy.pad() supports statistical modes (mean, maximum, minimum) along multi-dimensional axes.","numpy.pad() accepts custom callable functions with pad_width, iaxis, and kwargs.","numpy.pad() raises ValueError when passed an unrecognized padding mode or negative pad width."],"goal":"verify numpy.pad in pkg:pypi/numpy@2.5.1","kind":"HOW","packages":["pkg:pypi/numpy@2.5.1"],"schemaVersion":1,"symbols":["numpy.pad"]},"contractCommand":["python","test/contract.py"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"pypi","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"pip","schemaVersion":1},"license":"MIT-0","packages":["pkg:pypi/numpy@2.5.1"],"schemaVersion":1,"subject":"pkg:pypi/numpy@2.5.1","symbols":["numpy.pad"],"verifierAdapter":"python@1"}

[project]
name = "verify-numpy-pad"
version = "0.1.0"
dependencies = [
    "numpy==2.5.1",
]

numpy==2.5.1

{
  "schemaVersion": 1,
  "goal": "verify numpy.pad in pkg:pypi/numpy@2.5.1",
  "kind": "HOW",
  "packages": [
    "pkg:pypi/numpy@2.5.1"
  ],
  "symbols": [
    "numpy.pad"
  ]
}

import numpy as np


def test_constant_mode():
    arr = np.array([1, 2, 3])
    # Default constant_values=0
    res_default = np.pad(arr, (2, 3), mode="constant")
    assert np.array_equal(res_default, [0, 0, 1, 2, 3, 0, 0, 0]), f"Got {res_default}"

    # Specified constant_values tuple
    res_custom = np.pad(arr, (1, 2), mode="constant", constant_values=(7, 9))
    assert np.array_equal(res_custom, [7, 1, 2, 3, 9, 9]), f"Got {res_custom}"


def test_edge_mode():
    arr = np.array([1, 2, 3])
    res = np.pad(arr, (2, 1), mode="edge")
    assert np.array_equal(res, [1, 1, 1, 2, 3, 3]), f"Got {res}"


def test_linear_ramp_mode():
    arr = np.array([1, 2, 3])
    res = np.pad(arr, (2, 2), mode="linear_ramp", end_values=(0, 5))
    assert np.array_equal(res, [0, 0, 1, 2, 3, 4, 5]), f"Got {res}"


def test_reflect_and_symmetric_modes():
    arr = np.array([1, 2, 3])
    # Reflect mode reflects without repeating the edge value
    res_reflect = np.pad(arr, (2, 2), mode="reflect")
    assert np.array_equal(res_reflect, [3, 2, 1, 2, 3, 2, 1]), f"Got {res_reflect}"

    # Symmetric mode reflects with edge value repeated
    res_symmetric = np.pad(arr, (2, 2), mode="symmetric")
    assert np.array_equal(res_symmetric, [2, 1, 1, 2, 3, 3, 2]), f"Got {res_symmetric}"


def test_wrap_mode():
    arr = np.array([1, 2, 3])
    res = np.pad(arr, (2, 3), mode="wrap")
    assert np.array_equal(res, [2, 3, 1, 2, 3, 1, 2, 3]), f"Got {res}"


def test_statistical_modes():
    matrix = np.array([[1.0, 2.0], [3.0, 4.0]])
    res_mean = np.pad(matrix, 1, mode="mean")
    assert res_mean.shape == (4, 4), f"Got shape {res_mean.shape}"
    assert np.array_equal(res_mean[1:3, 1:3], matrix)

    res_max = np.pad(matrix, 1, mode="maximum")
    assert res_max.shape == (4, 4), f"Got shape {res_max.shape}"
    assert np.array_equal(res_max[1:3, 1:3], matrix)

    res_min = np.pad(matrix, 1, mode="minimum")
    assert res_min.shape == (4, 4), f"Got shape {res_min.shape}"
    assert np.array_equal(res_min[1:3, 1:3], matrix)


def test_custom_callable():
    def custom_padder(vector, pad_width, iaxis, kwargs):
        pad_val = kwargs.get("val", 42)
        vector[:pad_width[0]] = pad_val
        vector[-pad_width[1]:] = pad_val

    arr = np.array([1, 2, 3])
    res = np.pad(arr, (1, 1), mode=custom_padder, val=99)
    assert np.array_equal(res, [99, 1, 2, 3, 99]), f"Got {res}"


def test_error_handling():
    arr = np.array([1, 2, 3])
    try:
        np.pad(arr, (1, 1), mode="nonexistent_mode")
        raise AssertionError("Expected ValueError on invalid mode")
    except (ValueError, KeyError):
        pass

    try:
        np.pad(arr, (-1, 2), mode="constant")
        raise AssertionError("Expected ValueError on negative pad width")
    except ValueError:
        pass


def main():
    test_constant_mode()
    test_edge_mode()
    test_linear_ramp_mode()
    test_reflect_and_symmetric_modes()
    test_wrap_mode()
    test_statistical_modes()
    test_custom_callable()
    test_error_handling()
    print("CONTRACT PASS: numpy.pad verified offline")


if __name__ == "__main__":
    main()