GitHub

API reference for SemVer.

A validated version; the constructor is Effect's make. == compares every part, build included.

Attributes

AttributeTypeDescription
majorint
minorint
patchint
prereleasetuple[Identifier, ...] = field(default=())
buildtuple[str, ...] = field(default=())

Functions

__init__

__init__(major, minor, patch, prerelease=(), build=()) -> None
ParameterTypeDescription
majorint
minorint
patchint
prereleasetuple[Identifier, ...] = ()
buildtuple[str, ...] = ()

format

format() -> str

MAJOR.MINOR.PATCH[-PRERELEASE][+BUILD].

Returns str

def format(self) -> str:
    """``MAJOR.MINOR.PATCH[-PRERELEASE][+BUILD]``."""
    out = f"{self.major}.{self.minor}.{self.patch}"
    if self.prerelease:
        out += "-" + ".".join(map(str, self.prerelease))
    if self.build:
        out += "+" + ".".join(self.build)
    return out

is_prerelease

is_prerelease() -> bool

Returns bool

def is_prerelease(self) -> bool:
    return bool(self.prerelease)

has_build

has_build() -> bool

Returns bool

def has_build(self) -> bool:
    return bool(self.build)

is_initial_development

is_initial_development() -> bool

Whether the major version is 0.

Returns bool

def is_initial_development(self) -> bool:
    """Whether the major version is 0."""
    return self.major == 0

with_prerelease

with_prerelease(prerelease) -> SemVer
ParameterTypeDescription
prereleaseSequence[Identifier]

Returns SemVer

def with_prerelease(self, prerelease: Sequence[Identifier]) -> SemVer:
    return SemVer(self.major, self.minor, self.patch, tuple(prerelease), self.build)

with_build

with_build(build) -> SemVer
ParameterTypeDescription
buildSequence[str]

Returns SemVer

def with_build(self, build: Sequence[str]) -> SemVer:
    return SemVer(self.major, self.minor, self.patch, self.prerelease, tuple(build))

release

release() -> SemVer

The version without pre-release and build.

Returns SemVer

def release(self) -> SemVer:
    """The version without pre-release and build."""
    if not self.prerelease and not self.build:
        return self
    return SemVer(self.major, self.minor, self.patch)

bump_major

bump_major() -> SemVer

Returns SemVer

def bump_major(self) -> SemVer:
    keep = self.minor == 0 and self.patch == 0 and bool(self.prerelease)
    return SemVer(self.major if keep else _increment(self.major, "major"), 0, 0)

bump_minor

bump_minor() -> SemVer

Returns SemVer

def bump_minor(self) -> SemVer:
    keep = self.patch == 0 and bool(self.prerelease)
    return SemVer(self.major, self.minor if keep else _increment(self.minor, "minor"), 0)

bump_patch

bump_patch() -> SemVer

Returns SemVer

def bump_patch(self) -> SemVer:
    patch = self.patch if self.prerelease else _increment(self.patch, "patch")
    return SemVer(self.major, self.minor, patch)

bump_premajor

bump_premajor(identifier=None) -> SemVer
ParameterTypeDescription
identifierstr | None = None

Returns SemVer

def bump_premajor(self, identifier: str | None = None) -> SemVer:
    return SemVer(_increment(self.major, "major"), 0, 0, _start_prerelease(identifier))

bump_preminor

bump_preminor(identifier=None) -> SemVer
ParameterTypeDescription
identifierstr | None = None

Returns SemVer

def bump_preminor(self, identifier: str | None = None) -> SemVer:
    minor = _increment(self.minor, "minor")
    return SemVer(self.major, minor, 0, _start_prerelease(identifier))

bump_prepatch

bump_prepatch(identifier=None) -> SemVer
ParameterTypeDescription
identifierstr | None = None

Returns SemVer

def bump_prepatch(self, identifier: str | None = None) -> SemVer:
    patch = _increment(self.patch, "patch")
    return SemVer(self.major, self.minor, patch, _start_prerelease(identifier))

bump_prerelease

bump_prerelease(identifier=None) -> SemVer
ParameterTypeDescription
identifierstr | None = None

Returns SemVer

def bump_prerelease(self, identifier: str | None = None) -> SemVer:
    if not self.prerelease:
        return self.bump_prepatch(identifier)
    if identifier is not None:
        normalized = prerelease_identifier(identifier)
        if self.prerelease[0] != normalized:
            return SemVer(self.major, self.minor, self.patch, (normalized, 0))
    return SemVer(self.major, self.minor, self.patch, _next_prerelease(self.prerelease))

bump

bump(release_type, identifier=None) -> SemVer

The next version of release_type, as npm's semver.inc.

ParameterTypeDescription
release_typeReleaseType
identifierstr | None = None

Returns SemVer

def bump(self, release_type: ReleaseType, identifier: str | None = None) -> SemVer:  # noqa: PLR0911
    """The next version of ``release_type``, as npm's ``semver.inc``."""
    match release_type:
        case "major":
            return self.bump_major()
        case "minor":
            return self.bump_minor()
        case "patch":
            return self.bump_patch()
        case "premajor":
            return self.bump_premajor(identifier)
        case "preminor":
            return self.bump_preminor(identifier)
        case "prepatch":
            return self.bump_prepatch(identifier)
        case "prerelease":
            return self.bump_prerelease(identifier)

difference

difference(that) -> ReleaseType | None

The release type between the two versions, as npm's semver.diff; None when they have the same precedence.

ParameterTypeDescription
thatSemVer

Returns ReleaseType | None

def difference(self, that: SemVer) -> ReleaseType | None:  # noqa: PLR0911
    """The release type between the two versions, as npm's
    ``semver.diff``; ``None`` when they have the same precedence."""
    comparison = compare_core(self, that)
    if comparison == 0:
        return None
    low, high = (self, that) if comparison < 0 else (that, self)
    high_pre = bool(high.prerelease)
    if low.prerelease and not high_pre:
        if low.minor == 0 and low.patch == 0:
            return "major"
        if same_core(low, high):
            return "minor" if low.patch == 0 else "patch"
    if self.major != that.major:
        return "premajor" if high_pre else "major"
    if self.minor != that.minor:
        return "preminor" if high_pre else "minor"
    if self.patch != that.patch:
        return "prepatch" if high_pre else "patch"
    return "prerelease"