requireit 0.1.0__tar.gz

requireit-0.1.0/AUTHORS.md

@@ -0,0 +1,5 @@
+# Credits
+
+## Development Leads
+
+- [Eric Hutton](https://github.com/mcflugen)

requireit-0.1.0/CHANGES.md

@@ -0,0 +1,11 @@
+# Release Notes
+
+## 0.1.0 (not yet released)
+
+- Added documentation to the README [#1](https://github.com/mcflugen/requireit/issues/1)
+- Added project metadata files [#2](https://github.com/mcflugen/requireit/issues/2)
+- Added the `requireit` module [#3](https://github.com/mcflugen/requireit/issues/3)
+- Added `pyproject.toml` file [#4](https://github.com/mcflugen/requireit/issues/4)
+- Added `noxfile.py` file and linters [#5](https://github.com/mcflugen/requireit/issues/5)
+- Added unit tests for `requireit` [#6](https://github.com/mcflugen/requireit/issues/6)
+- Added GitHub Actions for CI [#7](https://github.com/mcflugen/requireit/issues/7)

requireit-0.1.0/LICENSE.md

@@ -0,0 +1,24 @@
+# The MIT License (MIT)
+
+Copyright (c) 2026 Eric Hutton
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

requireit-0.1.0/PKG-INFO

@@ -0,0 +1,205 @@
+Metadata-Version: 2.4
+Name: requireit
+Version: 0.1.0
+Summary: Tiny runtime validators for explicit precondition checks
+Author-email: Eric Hutton <mcflugen@gmail.com>
+Maintainer-email: Eric Hutton <mcflugen@gmail.com>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/mcflugen/requireit
+Project-URL: documentation, https://github.com/mcflugen/requireit/blob/main/README.md
+Project-URL: repository, https://github.com/mcflugen/requireit
+Project-URL: changelog, https://github.com/mcflugen/requireit/blob/main/CHANGES.md
+Keywords: preconditions,runtime-checks,utilities,validation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: nox; extra == "dev"
+Dynamic: license-file
+
+# requireit
+
+**Tiny, numpy-aware runtime validators for explicit precondition checks.**
+
+`requireit` provides a small collection of lightweight helper functions such as
+`require_positive`, `require_between`, and `validate_array` for validating values
+and arrays at runtime.
+
+It is intentionally minimal and dependency-light (*numpy* only).
+
+## Why `requireit`?
+
+* **Explicit** – reads clearly
+* **numpy-aware** – works correctly with scalars *and* arrays
+* **Fail-fast** – raises immediately with clear error messages
+* **Lightweight** – just a bunch of small functions
+* **Reusable** – avoids copy-pasted validation code across projects
+
+```python
+from requireit import require_one_of
+from requireit import require_positive
+
+require_positive(dt)
+require_one_of(method, allowed={"foo", "bar"})
+```
+
+## Design principles
+
+* Prefer small, single-purpose functions
+* Raise standard exceptions (`ValidationError`)
+* Never coerce or "fix" invalid inputs
+* Validate *all* elements for array-like inputs
+* Keep the public API small
+
+## Non-goals
+
+`requireit` is **not**:
+
+* a schema or data-modeling system
+* a replacement for static typing
+* a validation framework
+* a substitute for unit tests
+* a coercion or parsing library
+
+If you need structured validation, transformations, or user-facing error
+aggregation, you probably want something heavier.
+
+## Installation
+
+```bash
+pip install requireit
+```
+
+## API overview
+
+All validators:
+
+* return the original value/array on success
+* raise `ValidationError` on failure
+
+### Membership validation
+
+```python
+require_one_of(value, *, allowed)
+```
+
+Validate that a value is one of a set of allowed values.
+
+```python
+require_one_of("foo", allowed=("foo", "bar"))  # ok, returns "foo"
+require_one_of("baz", allowed=("foo", "bar"))  # raises ValidationError
+```
+
+### Range validation
+
+```python
+require_between(
+    value,
+    a_min=None,
+    a_max=None,
+    *,
+    inclusive_min=True,
+    inclusive_max=True,
+)
+```
+
+Validate that a scalar or array lies within specified bounds.
+
+* Bounds may be inclusive or strict
+* Validation fails if **any element** violates the constraint
+
+```python
+require_between([0, 1], a_min=0.0) # ok, returns [0, 1]
+require_between([0, 1], a_min=0.0, inclusive_min=False) # raises
+```
+
+### Sign-based helpers
+
+Convenience wrappers around `require_between`:
+
+```python
+require_positive(value)  # > 0
+require_nonnegative(value)  # >= 0
+require_negative(value)  # < 0
+require_nonpositive(value)  # <= 0
+```
+
+All accept scalars or array-like inputs.
+
+
+### Array validation
+
+```python
+validate_array(
+    array,
+    *,
+    dtype=None,
+    shape=None,
+    writable=None,
+    contiguous=None,
+)
+```
+
+Validate NumPy array properties without copying or modifying the array.
+
+```python
+validate_array(x, dtype=np.float64, shape=(100,))
+validate_array(x, writable=True, contiguous=True)
+```
+
+Checks are applied only if the corresponding keyword is provided.
+
+
+## Errors
+
+All validation failures raise:
+
+```python
+requireit.ValidationError
+```
+
+This allows callers to catch validation failures distinctly from other errors.
+
+
+## Contributing
+
+This project is intentionally small.
+
+Contributions should preserve:
+
+* minimal surface area
+* explicit semantics
+* no additional dependencies
+
+If a proposed change needs much explanation, it probably doesn’t belong here.
+
+# Credits
+
+## Development Leads
+
+- [Eric Hutton](https://github.com/mcflugen)
+
+# Release Notes
+
+## 0.1.0 (not yet released)
+
+- Added documentation to the README [#1](https://github.com/mcflugen/requireit/issues/1)
+- Added project metadata files [#2](https://github.com/mcflugen/requireit/issues/2)
+- Added the `requireit` module [#3](https://github.com/mcflugen/requireit/issues/3)
+- Added `pyproject.toml` file [#4](https://github.com/mcflugen/requireit/issues/4)
+- Added `noxfile.py` file and linters [#5](https://github.com/mcflugen/requireit/issues/5)
+- Added unit tests for `requireit` [#6](https://github.com/mcflugen/requireit/issues/6)
+- Added GitHub Actions for CI [#7](https://github.com/mcflugen/requireit/issues/7)

requireit-0.1.0/README.md

@@ -0,0 +1,155 @@
+# requireit
+
+**Tiny, numpy-aware runtime validators for explicit precondition checks.**
+
+`requireit` provides a small collection of lightweight helper functions such as
+`require_positive`, `require_between`, and `validate_array` for validating values
+and arrays at runtime.
+
+It is intentionally minimal and dependency-light (*numpy* only).
+
+## Why `requireit`?
+
+* **Explicit** – reads clearly
+* **numpy-aware** – works correctly with scalars *and* arrays
+* **Fail-fast** – raises immediately with clear error messages
+* **Lightweight** – just a bunch of small functions
+* **Reusable** – avoids copy-pasted validation code across projects
+
+```python
+from requireit import require_one_of
+from requireit import require_positive
+
+require_positive(dt)
+require_one_of(method, allowed={"foo", "bar"})
+```
+
+## Design principles
+
+* Prefer small, single-purpose functions
+* Raise standard exceptions (`ValidationError`)
+* Never coerce or "fix" invalid inputs
+* Validate *all* elements for array-like inputs
+* Keep the public API small
+
+## Non-goals
+
+`requireit` is **not**:
+
+* a schema or data-modeling system
+* a replacement for static typing
+* a validation framework
+* a substitute for unit tests
+* a coercion or parsing library
+
+If you need structured validation, transformations, or user-facing error
+aggregation, you probably want something heavier.
+
+## Installation
+
+```bash
+pip install requireit
+```
+
+## API overview
+
+All validators:
+
+* return the original value/array on success
+* raise `ValidationError` on failure
+
+### Membership validation
+
+```python
+require_one_of(value, *, allowed)
+```
+
+Validate that a value is one of a set of allowed values.
+
+```python
+require_one_of("foo", allowed=("foo", "bar"))  # ok, returns "foo"
+require_one_of("baz", allowed=("foo", "bar"))  # raises ValidationError
+```
+
+### Range validation
+
+```python
+require_between(
+    value,
+    a_min=None,
+    a_max=None,
+    *,
+    inclusive_min=True,
+    inclusive_max=True,
+)
+```
+
+Validate that a scalar or array lies within specified bounds.
+
+* Bounds may be inclusive or strict
+* Validation fails if **any element** violates the constraint
+
+```python
+require_between([0, 1], a_min=0.0) # ok, returns [0, 1]
+require_between([0, 1], a_min=0.0, inclusive_min=False) # raises
+```
+
+### Sign-based helpers
+
+Convenience wrappers around `require_between`:
+
+```python
+require_positive(value)  # > 0
+require_nonnegative(value)  # >= 0
+require_negative(value)  # < 0
+require_nonpositive(value)  # <= 0
+```
+
+All accept scalars or array-like inputs.
+
+
+### Array validation
+
+```python
+validate_array(
+    array,
+    *,
+    dtype=None,
+    shape=None,
+    writable=None,
+    contiguous=None,
+)
+```
+
+Validate NumPy array properties without copying or modifying the array.
+
+```python
+validate_array(x, dtype=np.float64, shape=(100,))
+validate_array(x, writable=True, contiguous=True)
+```
+
+Checks are applied only if the corresponding keyword is provided.
+
+
+## Errors
+
+All validation failures raise:
+
+```python
+requireit.ValidationError
+```
+
+This allows callers to catch validation failures distinctly from other errors.
+
+
+## Contributing
+
+This project is intentionally small.
+
+Contributions should preserve:
+
+* minimal surface area
+* explicit semantics
+* no additional dependencies
+
+If a proposed change needs much explanation, it probably doesn’t belong here.

requireit-0.1.0/pyproject.toml

@@ -0,0 +1,80 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "requireit"
+description = "Tiny runtime validators for explicit precondition checks"
+authors = [
+  {name = "Eric Hutton", email = "mcflugen@gmail.com"},
+]
+maintainers = [
+  {name = "Eric Hutton", email = "mcflugen@gmail.com"},
+]
+keywords = [
+  "preconditions",
+  "runtime-checks",
+  "utilities",
+  "validation",
+]
+license = "MIT"
+license-files = ["LICENSE.md"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Operating System :: OS Independent",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: Implementation :: CPython",
+  "Programming Language :: Python :: Implementation :: PyPy",
+]
+requires-python = ">=3.10"
+dependencies = [
+  "numpy",
+]
+dynamic = ["readme", "version"]
+
+[project.urls]
+homepage = "https://github.com/mcflugen/requireit"
+documentation = "https://github.com/mcflugen/requireit/blob/main/README.md"
+repository = "https://github.com/mcflugen/requireit"
+changelog = "https://github.com/mcflugen/requireit/blob/main/CHANGES.md"
+
+[project.optional-dependencies]
+dev = ["nox"]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+py-modules = ["requireit"]
+
+[tool.setuptools.dynamic]
+readme = {file = ["README.md", "AUTHORS.md", "CHANGES.md"], content-type="text/markdown"}
+version = {attr = "requireit.__version__"}
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+testpaths = ["tests", "src/requireit.py"]
+norecursedirs = [".*", "*.egg*", "build", "dist", "utilities"]
+addopts = [
+  "--ignore=setup.py",
+  "--tb=native",
+  "--strict-config",
+  "--strict-markers",
+  "--durations=16",
+  "--doctest-modules",
+  "-vvv",
+]
+doctest_optionflags = [
+  "NORMALIZE_WHITESPACE",
+  "IGNORE_EXCEPTION_DETAIL",
+  "ALLOW_UNICODE"
+]
+
+[tool.isort]
+combine_as_imports = true
+profile = "black"

requireit-0.1.0/setup.cfg

@@ -0,0 +1,10 @@
+[flake8]
+exclude = build, .nox
+extend-ignore = B024, C901, E203
+max-line-length = 88
+max-complexity = 4
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

requireit-0.1.0/src/requireit.egg-info/PKG-INFO

@@ -0,0 +1,205 @@
+Metadata-Version: 2.4
+Name: requireit
+Version: 0.1.0
+Summary: Tiny runtime validators for explicit precondition checks
+Author-email: Eric Hutton <mcflugen@gmail.com>
+Maintainer-email: Eric Hutton <mcflugen@gmail.com>
+License-Expression: MIT
+Project-URL: homepage, https://github.com/mcflugen/requireit
+Project-URL: documentation, https://github.com/mcflugen/requireit/blob/main/README.md
+Project-URL: repository, https://github.com/mcflugen/requireit
+Project-URL: changelog, https://github.com/mcflugen/requireit/blob/main/CHANGES.md
+Keywords: preconditions,runtime-checks,utilities,validation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: nox; extra == "dev"
+Dynamic: license-file
+
+# requireit
+
+**Tiny, numpy-aware runtime validators for explicit precondition checks.**
+
+`requireit` provides a small collection of lightweight helper functions such as
+`require_positive`, `require_between`, and `validate_array` for validating values
+and arrays at runtime.
+
+It is intentionally minimal and dependency-light (*numpy* only).
+
+## Why `requireit`?
+
+* **Explicit** – reads clearly
+* **numpy-aware** – works correctly with scalars *and* arrays
+* **Fail-fast** – raises immediately with clear error messages
+* **Lightweight** – just a bunch of small functions
+* **Reusable** – avoids copy-pasted validation code across projects
+
+```python
+from requireit import require_one_of
+from requireit import require_positive
+
+require_positive(dt)
+require_one_of(method, allowed={"foo", "bar"})
+```
+
+## Design principles
+
+* Prefer small, single-purpose functions
+* Raise standard exceptions (`ValidationError`)
+* Never coerce or "fix" invalid inputs
+* Validate *all* elements for array-like inputs
+* Keep the public API small
+
+## Non-goals
+
+`requireit` is **not**:
+
+* a schema or data-modeling system
+* a replacement for static typing
+* a validation framework
+* a substitute for unit tests
+* a coercion or parsing library
+
+If you need structured validation, transformations, or user-facing error
+aggregation, you probably want something heavier.
+
+## Installation
+
+```bash
+pip install requireit
+```
+
+## API overview
+
+All validators:
+
+* return the original value/array on success
+* raise `ValidationError` on failure
+
+### Membership validation
+
+```python
+require_one_of(value, *, allowed)
+```
+
+Validate that a value is one of a set of allowed values.
+
+```python
+require_one_of("foo", allowed=("foo", "bar"))  # ok, returns "foo"
+require_one_of("baz", allowed=("foo", "bar"))  # raises ValidationError
+```
+
+### Range validation
+
+```python
+require_between(
+    value,
+    a_min=None,
+    a_max=None,
+    *,
+    inclusive_min=True,
+    inclusive_max=True,
+)
+```
+
+Validate that a scalar or array lies within specified bounds.
+
+* Bounds may be inclusive or strict
+* Validation fails if **any element** violates the constraint
+
+```python
+require_between([0, 1], a_min=0.0) # ok, returns [0, 1]
+require_between([0, 1], a_min=0.0, inclusive_min=False) # raises
+```
+
+### Sign-based helpers
+
+Convenience wrappers around `require_between`:
+
+```python
+require_positive(value)  # > 0
+require_nonnegative(value)  # >= 0
+require_negative(value)  # < 0
+require_nonpositive(value)  # <= 0
+```
+
+All accept scalars or array-like inputs.
+
+
+### Array validation
+
+```python
+validate_array(
+    array,
+    *,
+    dtype=None,
+    shape=None,
+    writable=None,
+    contiguous=None,
+)
+```
+
+Validate NumPy array properties without copying or modifying the array.
+
+```python
+validate_array(x, dtype=np.float64, shape=(100,))
+validate_array(x, writable=True, contiguous=True)
+```
+
+Checks are applied only if the corresponding keyword is provided.
+
+
+## Errors
+
+All validation failures raise:
+
+```python
+requireit.ValidationError
+```
+
+This allows callers to catch validation failures distinctly from other errors.
+
+
+## Contributing
+
+This project is intentionally small.
+
+Contributions should preserve:
+
+* minimal surface area
+* explicit semantics
+* no additional dependencies
+
+If a proposed change needs much explanation, it probably doesn’t belong here.
+
+# Credits
+
+## Development Leads
+
+- [Eric Hutton](https://github.com/mcflugen)
+
+# Release Notes
+
+## 0.1.0 (not yet released)
+
+- Added documentation to the README [#1](https://github.com/mcflugen/requireit/issues/1)
+- Added project metadata files [#2](https://github.com/mcflugen/requireit/issues/2)
+- Added the `requireit` module [#3](https://github.com/mcflugen/requireit/issues/3)
+- Added `pyproject.toml` file [#4](https://github.com/mcflugen/requireit/issues/4)
+- Added `noxfile.py` file and linters [#5](https://github.com/mcflugen/requireit/issues/5)
+- Added unit tests for `requireit` [#6](https://github.com/mcflugen/requireit/issues/6)
+- Added GitHub Actions for CI [#7](https://github.com/mcflugen/requireit/issues/7)

requireit-0.1.0/src/requireit.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+AUTHORS.md
+CHANGES.md
+LICENSE.md
+README.md
+pyproject.toml
+setup.cfg
+src/requireit.py
+src/requireit.egg-info/PKG-INFO
+src/requireit.egg-info/SOURCES.txt
+src/requireit.egg-info/dependency_links.txt
+src/requireit.egg-info/requires.txt
+src/requireit.egg-info/top_level.txt

requireit-0.1.0/src/requireit.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

requireit-0.1.0/src/requireit.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy
+
+[dev]
+nox

requireit-0.1.0/src/requireit.egg-info/top_level.txt

@@ -0,0 +1 @@
+requireit

requireit-0.1.0/src/requireit.py

@@ -0,0 +1,306 @@
+from collections.abc import Callable
+from collections.abc import Collection
+from collections.abc import Iterable
+from typing import Any
+
+import numpy as np
+from numpy.typing import ArrayLike
+from numpy.typing import DTypeLike
+from numpy.typing import NDArray
+
+__version__ = "0.1.0"
+
+
+class RequireItError(Exception):
+    """Base class for exceptions raised from this module."""
+
+
+class ValidationError(RequireItError):
+    """Error to indicate that a validation has failed."""
+
+
+def require_one_of(value: Any, *, allowed: Iterable[Any]) -> Any:
+    """Validate that ``value`` is one of ``allowed``.
+
+    Parameters
+    ----------
+    value : any
+        A scalar value to validate.
+    allowed : iterable of any
+        Allowed values.
+
+    Returns
+    -------
+    any
+        The original value.
+
+    Raises
+    ------
+    ValidationError
+        If the value is not in ``allowed``.
+
+    Examples
+    --------
+    >>> require_one_of("foo", allowed=("foo", "bar"))
+    'foo'
+    >>> require_one_of("baz", allowed=("foo", "bar"))
+    Traceback (most recent call last):
+    ...
+    requireit.ValidationError: invalid value: 'baz' is not one of 'bar', 'foo'
+    >>> require_one_of("Foo", allowed=("foo", "bar"))
+    Traceback (most recent call last):
+    ...
+    requireit.ValidationError: invalid value: 'Foo' is not one of 'bar', 'foo'
+    """
+    try:
+        collection_of_allowed: Collection = set(allowed)
+        in_collection = value in collection_of_allowed
+    except TypeError:
+        collection_of_allowed = list(allowed)
+        in_collection = value in collection_of_allowed
+
+    if not in_collection:
+        allowed_str = ", ".join(sorted(repr(x) for x in collection_of_allowed))
+        raise ValidationError(f"invalid value: {value!r} is not one of {allowed_str}")
+    return value
+
+
+def require_between(
+    value: ArrayLike,
+    a_min: float | None = None,
+    a_max: float | None = None,
+    *,
+    inclusive_min: bool = True,
+    inclusive_max: bool = True,
+) -> ArrayLike:
+    """Validate that a value lies within a specified interval.
+
+    Parameters
+    ----------
+    value : scalar or array-like
+        The input value(s) to be validated.
+    a_min : float or None, optional
+        Minimum allowable value. If ``None``, no lower bound is applied.
+    a_max : float or None, optional
+        Maximum allowable value. If ``None``, no upper bound is applied.
+    inclusive_min : bool, optional
+        If ``True`` (default), the lower bound is inclusive (``>=``).
+        If ``False``, the lower bound is strict (``>``).
+    inclusive_max : bool, optional
+        If ``True`` (default), the upper bound is inclusive (``<=``).
+        If ``False``, the upper bound is strict (``<``).
+
+    Returns
+    -------
+    value : scalar or array-like
+        The validated value.
+
+    Raises
+    ------
+    ValidationError
+        If any element of ``value`` violates the specified bounds.
+
+    Examples
+    --------
+    >>> require_between([0, 1], a_min=0.0, inclusive_min=True)
+    [0, 1]
+    >>> require_between([0, 1], a_min=0.0, inclusive_min=False)
+    Traceback (most recent call last):
+    ...
+    requireit.ValidationError: value must be > 0.0
+    """
+    arr = np.asarray(value)
+
+    if a_min is not None:
+        cmp: Callable = np.less if inclusive_min else np.less_equal
+        op = ">=" if inclusive_min else ">"
+        if np.any(cmp(arr, a_min)):
+            raise ValidationError(f"value must be {op} {a_min}")
+
+    if a_max is not None:
+        cmp = np.greater if inclusive_max else np.greater_equal
+        op = "<=" if inclusive_max else "<"
+        if np.any(cmp(arr, a_max)):
+            raise ValidationError(f"value must be {op} {a_max}")
+
+    return value
+
+
+def require_positive(value: ArrayLike) -> ArrayLike:
+    """Validate that a value is strictly greater than zero.
+
+    Parameters
+    ----------
+    value : scalar or array-like
+        The input value(s) to be validated.
+
+    Returns
+    -------
+    value : scalar or array-like
+        The validated value.
+
+    Raises
+    ------
+    ValidationError
+        If any element of ``value`` is less than or equal to zero.
+
+    Examples
+    --------
+    >>> require_positive(1.0)
+    1.0
+    >>> require_positive(0.0)
+    Traceback (most recent call last):
+    ...
+    requireit.ValidationError: value must be > 0.0
+    """
+    return require_between(value, a_min=0.0, a_max=None, inclusive_min=False)
+
+
+def require_nonnegative(value: ArrayLike) -> ArrayLike:
+    """Validate that a value is greater than or equal to zero.
+
+    Parameters
+    ----------
+    value : scalar or array-like
+        The input value(s) to be validated.
+
+    Returns
+    -------
+    value : scalar or array-like
+        The validated value.
+
+    Raises
+    ------
+    ValidationError
+        If any element of ``value`` is less than zero.
+
+    Examples
+    --------
+    >>> require_nonnegative(-1.0)
+    Traceback (most recent call last):
+    ...
+    requireit.ValidationError: value must be >= 0.0
+    >>> require_nonnegative(0.0)
+    0.0
+    >>> require_nonnegative(1.0)
+    1.0
+    """
+    return require_between(value, a_min=0.0, a_max=None, inclusive_min=True)
+
+
+def require_negative(value: ArrayLike) -> ArrayLike:
+    """Validate that a value is strictly less than zero.
+
+    Parameters
+    ----------
+    value : scalar or array-like
+        The input value(s) to be validated.
+
+    Returns
+    -------
+    value : scalar or array-like
+        The validated value.
+
+    Raises
+    ------
+    ValidationError
+        If any element of ``value`` is greater than or equal to zero.
+
+    Examples
+    --------
+    >>> require_negative(-1.0)
+    -1.0
+    >>> require_negative(0.0)
+    Traceback (most recent call last):
+    ...
+    requireit.ValidationError: value must be < 0.0
+    """
+    return require_between(value, a_min=None, a_max=0.0, inclusive_max=False)
+
+
+def require_nonpositive(value: ArrayLike) -> ArrayLike:
+    """Validate that a value is less than or equal to zero.
+
+    Parameters
+    ----------
+    value : scalar or array-like
+        The input value(s) to be validated.
+
+    Returns
+    -------
+    value : scalar or array-like
+        The validated value.
+
+    Raises
+    ------
+    ValidationError
+        If any element of ``value`` is greater than zero.
+
+    Examples
+    --------
+    >>> require_nonpositive(-1.0)
+    -1.0
+    >>> require_nonpositive(0.0)
+    0.0
+    >>> require_nonpositive(1.0)
+    Traceback (most recent call last):
+    ...
+    requireit.ValidationError: value must be <= 0.0
+    """
+    return require_between(value, a_min=None, a_max=0.0, inclusive_max=True)
+
+
+def validate_array(
+    array: NDArray,
+    *,
+    dtype: DTypeLike | None = None,
+    shape: tuple[int, ...] | None = None,
+    writable: bool | None = None,
+    contiguous: bool | None = None,
+):
+    """Validate an array to satisfy requirements.
+
+    Parameters
+    ----------
+    array : ndarray
+        The array to be validated.
+    dtype : data-type, optional
+        The required data type.
+    shape : tuple of int, optional
+        The required shape.
+    writable : bool, optional
+        Require the array to be writable.
+    contiguous : bool, optional
+        Require the array to be c-contiguous.
+
+    Returns
+    -------
+    array : ndarray
+        The validated array.
+
+    Raises
+    ------
+    ValidationError
+        If the array is invalid.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> validate_array(np.array([1, 2, 3, 4]), shape=(2, 2))
+    Traceback (most recent call last):
+    ...
+    requireit.ValidationError: incorrect shape: expected (2, 2), got (4,)
+    """
+    if shape is not None and array.shape != shape:
+        raise ValidationError(f"incorrect shape: expected {shape}, got {array.shape}")
+
+    if dtype is not None and array.dtype != np.dtype(dtype):
+        raise ValidationError(f"incorrect type: expected {dtype}, got {array.dtype}")
+
+    if writable and not array.flags.writeable:
+        raise ValidationError("array is not writable")
+
+    if contiguous and not array.flags.c_contiguous:
+        raise ValidationError("array is not contiguous")
+
+    return array