版本 1.10.0，为什么被排在 1.9.0 前面？

"""A bounded SemVer 2.0.0 precedence lesson, not a dependency resolver.

Accepts at most 200 ASCII characters per input. This size limit is local
teaching policy, not a length restriction imposed by the SemVer specification.
"""
from dataclasses import dataclass
from functools import cmp_to_key
from itertools import product
from pathlib import Path
import json
import re


PATTERN = re.compile(
    r"(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)"
    r"(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?"
    r"(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?"
)


@dataclass(frozen=True)
class Version:
    text: str
    core: tuple
    pre: tuple
    build: tuple


def parse(text):
    if not isinstance(text, str) or not 1 <= len(text) <= 200:
        raise ValueError("use a version string of 1..200 characters")
    match = PATTERN.fullmatch(text)
    if match is None:
        raise ValueError("invalid SemVer 2.0.0 syntax")
    major, minor, patch, pre, build = match.groups()
    pre = tuple(pre.split(".")) if pre else ()
    if any(part.isdigit() and len(part) > 1 and part[0] == "0" for part in pre):
        raise ValueError("numeric prerelease identifiers cannot have leading zeroes")
    return Version(text, (int(major), int(minor), int(patch)), pre,
                   tuple(build.split(".")) if build else ())


def sign_compare(left, right):
    return (left > right) - (left < right)


def compare(left, right):
    if left.core != right.core:
        return sign_compare(left.core, right.core)
    if not left.pre or not right.pre:
        return sign_compare(not left.pre, not right.pre)
    for a, b in zip(left.pre, right.pre):
        if a == b:
            continue
        a_numeric, b_numeric = a.isdigit(), b.isdigit()
        if a_numeric and b_numeric:
            return sign_compare(int(a), int(b))
        if a_numeric != b_numeric:
            return -1 if a_numeric else 1
        return sign_compare(a, b)  # ASCII input was enforced by the parser.
    return sign_compare(len(left.pre), len(right.pre))


def main():
    # Spec rule 11's published precedence chain is an external expected order.
    expected = ["1.0.0-alpha", "1.0.0-alpha.1", "1.0.0-alpha.beta", "1.0.0-beta",
                "1.0.0-beta.2", "1.0.0-beta.11", "1.0.0-rc.1", "1.0.0"]
    assert [v.text for v in sorted(map(parse, reversed(expected)), key=cmp_to_key(compare))] == expected
    assert all(compare(parse(a), parse(b)) == -1 for a, b in zip(expected, expected[1:]))
    assert compare(parse("1.9.0"), parse("1.10.0")) == -1
    assert compare(parse("1.0.0-2"), parse("1.0.0-alpha")) == -1
    assert compare(parse("1.0.0-A"), parse("1.0.0-a")) == -1
    assert compare(parse("1.0.0-1a"), parse("1.0.0-01a")) == 1
    assert compare(parse("1.0.0+build.2"), parse("1.0.0+build.11")) == 0
    assert compare(parse("1.0.0+001"), parse("1.0.0+1")) == 0
    assert parse("1.0.0+001").text != parse("1.0.0+1").text

    rejected = ["1.2", "v1.2.3", "01.2.3", "1.2.3-01", "1.2.3-", "1.2.3+",
                "1.2.3-alpha..1", "1.2.3+two+three", "１.2.3", " 1.2.3", "1.2.3\n"]
    for text in rejected:
        try:
            parse(text)
        except ValueError:
            pass
        else:
            raise AssertionError("invalid fixture accepted: " + repr(text))
    assert parse("1.2.3-01a+001").build == ("001",)

    examples = ["1.9.0", "1.10.0", "1.10.0-rc.11", "1.10.0-rc.2",
                "1.10.0+build.11", "1.10.0+build.2", "2.0.0-alpha", "0.10.0"]
    versions = list(map(parse, examples))
    # Check order properties on the observed set, independently of one printed sort.
    for a, b in product(versions, repeat=2):
        assert compare(a, b) == -compare(b, a)
    for a, b, c in product(versions, repeat=3):
        if compare(a, b) <= 0 and compare(b, c) <= 0:
            assert compare(a, c) <= 0
    ordered = sorted(versions, key=cmp_to_key(compare))
    tied_input = ["1.0.0+z", "1.0.0+a"]
    tied_output = [v.text for v in sorted(map(parse, tied_input), key=cmp_to_key(compare))]
    assert tied_input == tied_output  # Stable display order, not build priority.
    report = {
        "scheme": "SemVer 2.0.0 precedence; teaching input length <= 200",
        "input": examples, "text_sort": sorted(examples),
        "precedence_sort": [v.text for v in ordered],
        "parts": [{"text": v.text, "core": v.core, "prerelease": v.pre, "build": v.build} for v in versions],
        "same_precedence_different_text": {"input": tied_input, "stable_output": tied_output,
                                          "comparison": compare(*map(parse, tied_input))},
        "rejected_inputs": rejected,
        "scope": "No installation, Maven/npm resolution, compatibility proof or artifact integrity check.",
    }
    Path("version-order-report.json").write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
    print("text order:", ", ".join(report["text_sort"]))
    print("SemVer precedence:", ", ".join(report["precedence_sort"]))
    print("same precedence, different text:", tied_output)
    print("PASS: published chain, syntax edges, antisymmetry, transitivity and stable ties")


if __name__ == "__main__":
    main()