validation.isbn

def validate_isbn(value: str) -> IsbnCheck

@dataclass(frozen=True)
class IsbnCheck:
    """The result of checking an ISBN. Every string is null when valid is false; reason is null when it is true."""

    valid: bool
    #: the ISBN-13, digits only
    normalised: Optional[str]
    #: the ISBN-10 equivalent; null for 979 ISBNs, which have none
    isbn10: Optional[str]
    #: empty, bad-character, bad-length, bad-format, bad-prefix or bad-check-digit
    reason: Optional[str]

from fune.validation.isbn import validate_isbn  # validation.isbn@^1

from typing import List, Optional

from .validation_isbn_types import IsbnCheck


def _invalid(reason: str) -> IsbnCheck:
    return IsbnCheck(valid=False, normalised=None, isbn10=None, reason=reason)


def _ean_check(twelve: str) -> str:
    """The EAN-13 check digit for twelve digits: weights 1, 3, 1, 3 ... from the left."""
    total = sum((ord(twelve[i]) - 48) * (1 if i % 2 == 0 else 3) for i in range(12))
    return str((10 - total % 10) % 10)


def _isbn10_check(nine: str) -> str:
    """The ISBN-10 check character for nine digits: weights 10 down to 2, mod 11, 10 written X."""
    total = sum((ord(nine[i]) - 48) * (10 - i) for i in range(9))
    check = (11 - total % 11) % 11
    return "X" if check == 10 else str(check)


def validate_isbn(value: str) -> IsbnCheck:
    """Check an ISBN-10 or ISBN-13 and return it as an ISBN-13, with its
    ISBN-10 where one exists.

    The two forms use different check digits, so conversion recomputes rather
    than copies. Validators answer rather than raise.
    """
    if not isinstance(value, str):
        return _invalid("empty")

    # Hyphen positions vary by publisher, so separators are ignored wholesale.
    compact = "".join(ch for ch in value if ch != " " and ch != "-")
    # An optional "ISBN" label, any case, then an optional colon. Folded by
    # hand: str.upper() is Unicode-aware and the Rust sibling is not.
    if len(compact) >= 4:
        label = "".join(chr(ord(c) - 32) if "a" <= c <= "z" else c for c in compact[:4])
        if label == "ISBN":
            compact = compact[4:]
    if compact.startswith(":"):
        compact = compact[1:]
    if not compact:
        return _invalid("empty")

    out: List[str] = []
    for ch in compact:
        if "0" <= ch <= "9":
            out.append(ch)
        elif ch == "X" or ch == "x":
            out.append("X")
        else:
            return _invalid("bad-character")
    isbn = "".join(out)
    if len(isbn) != 10 and len(isbn) != 13:
        return _invalid("bad-length")
    # X means ten, so it can only be an ISBN-10's check digit.
    x_at = isbn.find("X")
    if x_at != -1 and (len(isbn) == 13 or x_at != 9):
        return _invalid("bad-format")

    if len(isbn) == 13:
        prefix = isbn[:3]
        if prefix != "978" and prefix != "979":
            return _invalid("bad-prefix")
        if _ean_check(isbn) != isbn[12]:
            return _invalid("bad-check-digit")
        # 979 ISBNs were never ISBN-10s, so they have no ISBN-10 to give back.
        isbn10: Optional[str] = isbn[3:12] + _isbn10_check(isbn[3:12]) if prefix == "978" else None
        return IsbnCheck(valid=True, normalised=isbn, isbn10=isbn10, reason=None)

    if _isbn10_check(isbn) != isbn[9]:
        return _invalid("bad-check-digit")
    body = "978" + isbn[:9]
    return IsbnCheck(valid=True, normalised=body + _ean_check(body), isbn10=isbn, reason=None)

Install

fune build

With that line in your source, in a Python project (language python in fune.project), fune build resolves it and nothing else, pins them in fune.lock, downloads only the Python package of each, and builds the code above into your project’s .fune/build, one readable file per capability with a header linking back here. Or pin a range in fune.project and build in one step:

fune add validation.isbn

The manifest, vectors and README with only the Python implementation. Install it without the registry with fune add ./validation.isbn-1.0.0-python.fune, or fetch it from a terminal with fune pull validation.isbn@1.0.0:python.

The whole function, every language, is one file too: validation.isbn-1.0.0.fune, 19,171 bytes, sha256 8172c558a9fcbd41bc83843d50404321a07e6af6e93416743fbf2dbf57cced2f. It installs into a project of any language.

# fune: before validation.isbn

# fune: after validation.isbn

# fune: step validation.isbn after <n|label>

More from the author

- ISBN-10: weight the ten characters 10, 9, 8 ... 1 and the sum must be a multiple of 11. The check digit can therefore be 10, written `X` (or `x`), and `X` is allowed only in that last position. - ISBN-13: the GS1/EAN-13 rule - weights 1, 3, 1, 3 ... from the left, and the check digit brings the sum to a multiple of 10. The first three digits must be 978 or 979 ("Bookland"); any other EAN-13 is a barcode, not an ISBN.

CONVERSION is where naive code goes wrong: the two check digits are computed differently, so converting means recomputing, never copying the old check digit across. An ISBN-10 becomes `978` + its first nine digits + a fresh EAN check digit. An ISBN-13 has an ISBN-10 only when it starts with 978; `979` ISBNs (issued since the 978 range began running out) have none, and `isbn10` is null for them.

ACCEPTED INPUT: ASCII digits and `X`, with ASCII spaces and hyphens ignored anywhere (hyphen positions depend on the registration group and publisher, so they are not checked), and an optional leading `ISBN` in any case, optionally followed by a colon: `ISBN 978-0-306-40615-7`, `isbn:0306406152`. Forms such as `ISBN-13:` are not recognised.

| reason | meaning | |-------------------|------------------------------------------------------------------| | `empty` | nothing left after removing separators and the prefix, or not a string | | `bad-character` | a character other than a digit, `X`, space or hyphen | | `bad-length` | not 10 or 13 characters | | `bad-format` | an `X` anywhere but the last place of an ISBN-10 | | `bad-prefix` | a 13-digit number that does not start with 978 or 979 | | `bad-check-digit` | the check digit does not match |

The checks run in that order; the first failure is the reason. Validators answer rather than throw.

A valid ISBN is well formed, not necessarily assigned: only the ISBN agency's records say whether a book carries it. Hyphenation (splitting into group, publisher, title and check) needs the International ISBN Agency's range table and is out of scope.

Source: International ISBN Agency, ISBN Users' Manual, 7th edition, sections 5 and 9 (https://www.isbn-international.org/content/isbn-users-manual).

Files