super-easy-validator-python 0.1.0__py3-none-any.whl

super_easy_validator_python/__init__.py

@@ -0,0 +1,55 @@
+"""Validate data with rules you write as plain strings.
+
+    from super_easy_validator_python import validate
+
+    rules = {
+        "name": "fullname",
+        "email": "email",
+        "age": "optional|natural|min:18",
+        "role": "enums:admin,user,guest",
+    }
+
+    result = validate(rules, data)
+    if result.errors:
+        print(result.errors)
+
+Rules are a plain dict, so a whole rule tree can be loaded from JSON or built
+at runtime. See DOCS.md for the full reference.
+"""
+
+from .codes import ErrorCodes
+from .types import (
+    Config,
+    CustomRule,
+    Data,
+    Detail,
+    InvalidRuleError,
+    Result,
+    Rules,
+    ValidationError,
+    QUOTE_BACKTICK,
+    QUOTE_DOUBLE,
+    QUOTE_NONE,
+    QUOTE_SINGLE,
+)
+from .validator import validate
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "validate",
+    "ErrorCodes",
+    "Config",
+    "Result",
+    "Rules",
+    "Data",
+    "Detail",
+    "CustomRule",
+    "InvalidRuleError",
+    "ValidationError",
+    "QUOTE_NONE",
+    "QUOTE_SINGLE",
+    "QUOTE_DOUBLE",
+    "QUOTE_BACKTICK",
+    "__version__",
+]

super_easy_validator_python/checks.py

@@ -0,0 +1,525 @@
+"""Checks for a single value against a list of rule tokens."""
+
+from __future__ import annotations
+
+import math
+import re
+from datetime import datetime, timezone
+from typing import Any, Optional
+
+from . import codes
+from .formats import FORMAT_PATTERNS, translate_user_regex
+from .paths import is_array, is_object
+from .rules import (
+    DATA_TYPES,
+    NUMBER_TYPES,
+    STRING_FORMATS,
+    ARGUMENT_RULES,
+    custom_error,
+    custom_field,
+    has_token,
+    numeric_context,
+    split_arg,
+    string_context,
+)
+from .types import Detail
+
+_MISSING = object()
+
+#: Message fragments that differ between a number and a numeric string.
+_NUMBER_WORD = {False: "number", True: "numeric string"}
+
+
+def is_number(value: Any) -> bool:
+    """A number is an int or float, but never a bool.
+
+    ``isinstance(True, int)`` is True in Python, so booleans would otherwise
+    satisfy every numeric rule.
+    """
+    if isinstance(value, bool):
+        return False
+    return isinstance(value, (int, float))
+
+
+def to_number(value: Any) -> Optional[float]:
+    """Coerce a value to a float for comparison, or None if it is not numeric."""
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        return float(value)
+    if isinstance(value, str):
+        try:
+            return float(value.strip())
+        except ValueError:
+            return None
+    return None
+
+
+def number_text(value: Any) -> str:
+    """Render a number the way the digit-counting rules read it."""
+    if isinstance(value, str):
+        return value.strip()
+    if isinstance(value, float) and value.is_integer() and not math.isinf(value):
+        return str(int(value))
+    return str(value)
+
+
+def _is_integral(value: Any) -> bool:
+    """Whether a value has no fractional part."""
+    if isinstance(value, int) and not isinstance(value, bool):
+        return True
+    if isinstance(value, float):
+        return not math.isnan(value) and not math.isinf(value) and value.is_integer()
+    return False
+
+
+class Checker:
+    """Accumulates failures for one field.
+
+    ``start`` records how many errors the shared list already held, so
+    ``failed`` asks "did this field fail", not "has anything failed so far".
+    """
+
+    __slots__ = ("key", "prefix", "tokens", "errors", "start")
+
+    def __init__(self, key: str, prefix: str, tokens: list[str], errors: list[Detail]) -> None:
+        self.key = key
+        self.prefix = prefix
+        self.tokens = tokens
+        self.errors = errors
+        self.start = len(errors)
+
+    @property
+    def label(self) -> str:
+        name = custom_field(self.tokens, self.key) or self.key
+        return f"{self.prefix}.{name}" if self.prefix else name
+
+    @property
+    def failed(self) -> bool:
+        return len(self.errors) > self.start
+
+    def fail(self, code: str, message: str) -> None:
+        override = custom_error(self.tokens)
+        self.errors.append(
+            {"field": self.label, "message": override if override is not None else message, "code": code}
+        )
+
+    def require_present(self, value: Any, present: bool) -> bool:
+        if not present or value is None:
+            self.fail(codes.REQUIRED, f'"{self.label}" is required')
+            return False
+        return True
+
+
+def check_single(
+    key: str,
+    prefix: str,
+    value: Any,
+    present: bool,
+    tokens: list[str],
+    errors: list[Detail],
+) -> None:
+    """Apply a token list to one value, stopping at the first failure."""
+    c = Checker(key, prefix, tokens, errors)
+
+    # optional keys off absence; nullable keys off an explicit None.
+    if has_token(tokens, "optional") and not present:
+        return
+    if has_token(tokens, "nullable") and present and value is None:
+        return
+
+    for i, token in enumerate(tokens):
+        previous = tokens[:i]
+
+        if token in ("optional", "nullable", ""):
+            continue
+
+        if token in DATA_TYPES:
+            check_data_type(c, value, present, token, previous)
+        elif token in STRING_FORMATS:
+            check_string_format(c, value, present, token, previous)
+        elif token in NUMBER_TYPES:
+            check_number_type(c, value, present, token, previous)
+        elif token.startswith("arrayof:"):
+            check_array_of(c, value, present, token, previous)
+        else:
+            parts = split_arg(token)
+            if parts is not None and parts[0] in ARGUMENT_RULES:
+                kind, arg = parts
+                if kind in ("field", "error"):
+                    continue
+                check_constraint(c, value, present, kind, arg, previous)
+
+        if c.failed:
+            return
+
+
+def check_data_type(c: Checker, value: Any, present: bool, data_type: str, previous: list[str]) -> None:
+    if not c.require_present(value, present):
+        return
+
+    as_string = string_context(previous)
+
+    if data_type == "string":
+        if not isinstance(value, str):
+            c.fail(codes.NOT_STRING, f'"{c.label}" must be string')
+        return
+
+    if data_type == "number":
+        if as_string:
+            if not isinstance(value, str):
+                c.fail(codes.NOT_STRING, f'"{c.label}" must be string')
+                return
+            if to_number(value) is None:
+                c.fail(codes.NOT_NUMERIC_STRING, f'"{c.label}" must be a valid numeric string')
+            return
+        if not is_number(value):
+            c.fail(codes.NOT_NUMBER, f'"{c.label}" must be a valid number')
+        return
+
+    if data_type == "boolean":
+        if as_string:
+            if not isinstance(value, str) or value not in ("true", "false"):
+                c.fail(codes.NOT_BOOLEAN_STRING, f'"{c.label}" must be a valid boolean string')
+            return
+        if not isinstance(value, bool):
+            c.fail(codes.NOT_BOOLEAN, f'"{c.label}" must be a valid boolean')
+        return
+
+    if data_type == "array":
+        if not is_array(value):
+            c.fail(codes.NOT_ARRAY, f'"{c.label}" must be an array')
+        return
+
+    if data_type == "object":
+        if not is_object(value):
+            c.fail(codes.NOT_OBJECT, f'"{c.label}" must be an object')
+        return
+
+
+_FORMAT_CODES = {
+    "email": (codes.NOT_EMAIL, "must be a valid email"),
+    "url": (codes.NOT_URL, "must be a valid url"),
+    "domain": (codes.NOT_DOMAIN, "must be a valid domain"),
+    "name": (codes.NOT_NAME, "must be a valid name"),
+    "fullname": (codes.NOT_FULLNAME, "must be a valid fullname"),
+    "username": (codes.NOT_USERNAME, "must be a valid username"),
+    "alpha": (codes.NOT_ALPHA, "must be a valid alpha"),
+    "alphanumeric": (codes.NOT_ALPHANUMERIC, "must be a valid alphanumeric"),
+    "phone": (codes.NOT_PHONE, "must be a valid phone"),
+    "phonecode": (codes.NOT_PHONECODE, "must be a valid phone code"),
+    "objectid": (codes.NOT_OBJECTID, "must be a valid object id"),
+    "uuid": (codes.NOT_UUID, "must be a valid uuid"),
+    "date": (codes.NOT_DATE, "must be a valid date"),
+    "dateonly": (codes.NOT_DATEONLY, "must be a valid date"),
+    "time": (codes.NOT_TIME, "must be a valid time"),
+    "lower": (codes.NOT_LOWERCASE, "must not contains upper case letters"),
+    "upper": (codes.NOT_UPPERCASE, "must not contains lower case letters"),
+    "ip": (codes.NOT_IP, "must be a valid IP address"),
+}
+
+
+def check_string_format(c: Checker, value: Any, present: bool, fmt: str, previous: list[str]) -> None:
+    if not c.require_present(value, present):
+        return
+
+    check_data_type(c, value, present, "string", previous)
+    if c.failed:
+        return
+
+    pattern = FORMAT_PATTERNS[fmt]
+    if not pattern.search(value):
+        code, text = _FORMAT_CODES[fmt]
+        c.fail(code, f'"{c.label}" {text}')
+
+
+def check_number_type(c: Checker, value: Any, present: bool, num_type: str, previous: list[str]) -> None:
+    if not c.require_present(value, present):
+        return
+
+    check_data_type(c, value, present, "number", previous)
+    if c.failed:
+        return
+
+    as_string = string_context(previous)
+    word = _NUMBER_WORD[as_string]
+    n = to_number(value)
+    if n is None:
+        return
+
+    integral = _is_integral(float(n)) if as_string else _is_integral(value)
+
+    if num_type == "int":
+        if not integral:
+            label = "integer string" if as_string else "integer"
+            c.fail(codes.NOT_INTEGER, f'"{c.label}" must be a valid {label}')
+        return
+
+    if num_type == "positive":
+        if not n > 0:
+            c.fail(codes.NOT_POSITIVE, f'"{c.label}" must be a valid positive {word}')
+        return
+
+    if num_type == "negative":
+        if not n < 0:
+            c.fail(codes.NOT_NEGATIVE, f'"{c.label}" must be a valid negative {word}')
+        return
+
+    if num_type == "natural":
+        if not integral or n <= 0:
+            c.fail(codes.NOT_NATURAL, f'"{c.label}" must be a valid natural {word}')
+        return
+
+    if num_type == "whole":
+        if not integral or n < 0:
+            c.fail(codes.NOT_WHOLE, f'"{c.label}" must be a valid whole {word}')
+        return
+
+
+_ISO_FORMAT = "%Y-%m-%dT%H:%M:%S.%f"
+
+_DATE_LAYOUTS = (
+    "%Y-%m-%dT%H:%M:%S.%f",
+    "%Y-%m-%dT%H:%M:%S",
+    "%Y-%m-%d %H:%M:%S",
+    "%Y-%m-%d",
+    "%Y-%m",
+    "%Y",
+)
+
+
+def parse_date(text: str) -> Optional[datetime]:
+    raw = text.strip()
+    try:
+        parsed = datetime.fromisoformat(raw.replace("Z", "+00:00"))
+        return parsed.replace(tzinfo=None) if parsed.tzinfo is None else parsed.astimezone(timezone.utc).replace(tzinfo=None)
+    except ValueError:
+        pass
+    for layout in _DATE_LAYOUTS:
+        try:
+            return datetime.strptime(raw, layout)
+        except ValueError:
+            continue
+    return None
+
+
+def _iso(dt: datetime) -> str:
+    """Render a date the way the reference implementation reports bounds."""
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{dt.microsecond // 1000:03d}Z"
+
+
+def _decimals(text: str) -> tuple[int, bool]:
+    i = text.rfind(".")
+    if i < 0:
+        return 0, False
+    return len(text[i + 1 :]), True
+
+
+def check_constraint(
+    c: Checker, value: Any, present: bool, kind: str, arg: str, previous: list[str]
+) -> None:
+    if not c.require_present(value, present):
+        return
+
+    is_str = isinstance(value, str)
+    is_bool = isinstance(value, bool)
+    is_num = is_number(value)
+    numeric = numeric_context(previous)
+    arr = value if is_array(value) else None
+
+    if kind == "equal":
+        if is_str and value != arg:
+            c.fail(codes.NOT_EQUAL, f'"{c.label}" must be equal to {arg}')
+        elif is_num:
+            want = to_number(arg)
+            if want is None or float(value) != want:
+                c.fail(codes.NOT_EQUAL, f'"{c.label}" must be equal to {arg}')
+        elif is_bool:
+            if (arg == "true" and value is False) or (arg == "false" and value is True):
+                c.fail(codes.NOT_EQUAL, f'"{c.label}" must be equal to {arg}')
+        return
+
+    if kind == "size":
+        try:
+            size = int(arg)
+        except ValueError:
+            return
+        if is_str and not numeric:
+            if len(value) != size:
+                c.fail(codes.LENGTH_MISMATCH, f'"{c.label}" must have length {size}')
+        elif arr is not None:
+            if len(arr) != size:
+                c.fail(codes.LENGTH_MISMATCH, f'"{c.label}" must have length {size}')
+        elif is_num or (is_str and numeric):
+            digits = sum(1 for ch in number_text(value) if ch.isdigit())
+            if digits != size:
+                c.fail(codes.DIGITS_MISMATCH, f'"{c.label}" must have {size} digits')
+        return
+
+    if kind in ("min", "max"):
+        _check_bound(c, kind, arg, value, is_str, is_num, arr, numeric)
+        return
+
+    if kind == "regex":
+        try:
+            pattern = translate_user_regex(arg)
+        except ValueError:
+            return
+        if not is_str:
+            c.fail(codes.NOT_STRING, f'"{c.label}" must be of type string')
+            return
+        if not pattern.search(value):
+            c.fail(codes.REGEX_MISMATCH, f'"{c.label}" is invalid')
+        return
+
+    if kind in ("decimalsize", "decimalmin", "decimalmax"):
+        _check_decimals(c, kind, arg, value, is_str, is_num)
+        return
+
+    if kind == "enums":
+        options = arg.split(",")
+        if is_bool:
+            want = "true" if value else "false"
+            if want not in options:
+                c.fail(codes.ENUM_MISMATCH, f'"{c.label}" is invalid')
+            return
+        if is_str and not numeric:
+            if value not in options:
+                c.fail(codes.ENUM_MISMATCH, f'"{c.label}" is invalid')
+            return
+        if is_num or numeric:
+            target = to_number(value)
+            allowed = [n for n in (to_number(o) for o in options) if n is not None]
+            if target is None or target not in allowed:
+                c.fail(codes.ENUM_MISMATCH, f'"{c.label}" is invalid')
+        return
+
+
+def _check_bound(
+    c: Checker, kind: str, arg: str, value: Any, is_str: bool, is_num: bool, arr: Any, numeric: bool
+) -> None:
+    is_min = kind == "min"
+    bound = to_number(arg)
+
+    if bound is None:
+        limit = parse_date(arg)
+        if limit is None or not isinstance(value, str):
+            return
+        actual = parse_date(value)
+        if actual is None:
+            return
+        if is_min and actual < limit:
+            c.fail(codes.DATE_TOO_EARLY, f'"{c.label}" must be at least {_iso(limit)}')
+        elif not is_min and actual > limit:
+            c.fail(codes.DATE_TOO_LATE, f'"{c.label}" must be at most {_iso(limit)}')
+        return
+
+    if is_str and not numeric:
+        if is_min and len(value) < bound:
+            c.fail(codes.TOO_SHORT, f'"{c.label}" must have length of at least {arg}')
+        elif not is_min and len(value) > bound:
+            c.fail(codes.TOO_LONG, f'"{c.label}" must have length of at most {arg}')
+        return
+
+    if arr is not None:
+        if is_min and len(arr) < bound:
+            c.fail(codes.TOO_SHORT, f'"{c.label}" must have length of at least {arg}')
+        elif not is_min and len(arr) > bound:
+            c.fail(codes.TOO_LONG, f'"{c.label}" must have length of at most {arg}')
+        return
+
+    if is_num or (is_str and numeric):
+        actual = to_number(value)
+        if actual is None:
+            return
+        if is_min and actual < bound:
+            c.fail(codes.TOO_SMALL, f'"{c.label}" must be at least {arg}')
+        elif not is_min and actual > bound:
+            c.fail(codes.TOO_LARGE, f'"{c.label}" must be at most {arg}')
+
+
+def _check_decimals(c: Checker, kind: str, arg: str, value: Any, is_str: bool, is_num: bool) -> None:
+    try:
+        want = int(arg)
+    except ValueError:
+        return
+
+    if is_str:
+        if to_number(value) is None:
+            c.fail(codes.NOT_NUMERIC_STRING, f'"{c.label}" must be a valid numeric string')
+            return
+        text = value.strip()
+    elif is_num:
+        if isinstance(value, float) and math.isnan(value):
+            # Wording kept deliberately; the reference reads "a value number".
+            c.fail(codes.NOT_A_NUMBER, f'"{c.label}" must be a value number')
+            return
+        text = number_text(value)
+    else:
+        return
+
+    digits, has_point = _decimals(text)
+
+    if kind == "decimalsize":
+        if not has_point:
+            if want > 0:
+                c.fail(codes.DECIMAL_SIZE_MISMATCH, f'"{c.label}" must have {want} decimal places')
+            return
+        if digits != want:
+            c.fail(codes.DECIMAL_SIZE_MISMATCH, f'"{c.label}" must have {want} decimal places')
+        return
+
+    if kind == "decimalmin":
+        if not has_point:
+            if want > 0:
+                c.fail(codes.DECIMAL_TOO_FEW, f'"{c.label}" must have at least {want} decimal places')
+            return
+        if digits < want:
+            c.fail(codes.DECIMAL_TOO_FEW, f'"{c.label}" must have at least {want} decimal places')
+        return
+
+    if kind == "decimalmax":
+        if not has_point:
+            return
+        if digits > want:
+            c.fail(codes.DECIMAL_TOO_MANY, f'"{c.label}" must have at most {want} decimal places')
+
+
+def check_array_of(c: Checker, value: Any, present: bool, token: str, previous: list[str]) -> None:
+    """Apply the inner rule to every element, labelled by index."""
+    inner = token[len("arrayof:") :]
+
+    if not is_array(value):
+        c.fail(codes.NOT_ARRAY, f'"{c.label}" must be an array')
+        return
+
+    if inner in ("optional", "nullable"):
+        return
+
+    element_nullable = has_token(c.tokens, "arrayof:optional") or has_token(
+        c.tokens, "arrayof:nullable"
+    )
+
+    for i, element in enumerate(value):
+        missing = element is None
+        if element_nullable and missing:
+            continue
+
+        element_key = f"{c.label}[{i}]"
+        element_errors: list[Detail] = []
+        sub = Checker(element_key, "", c.tokens, element_errors)
+
+        if inner in DATA_TYPES:
+            check_data_type(sub, element, not missing, inner, previous)
+        elif inner in STRING_FORMATS:
+            check_string_format(sub, element, not missing, inner, previous)
+        elif inner in NUMBER_TYPES:
+            check_number_type(sub, element, not missing, inner, previous)
+        elif inner.startswith("arrayof:"):
+            check_array_of(sub, element, not missing, inner, previous)
+        else:
+            parts = split_arg(inner)
+            if parts is not None and parts[0] in ARGUMENT_RULES:
+                check_constraint(sub, element, not missing, parts[0], parts[1], previous)
+
+        c.errors.extend(element_errors)