A validated version; the constructor is Effect's make. ==
compares every part, build included.
Attributes#
| Attribute | Type | Description |
|---|---|---|
major | int | |
minor | int | |
patch | int | |
prerelease | tuple[Identifier, ...] = field(default=()) | |
build | tuple[str, ...] = field(default=()) |
Functions#
__init__#
__init__(major, minor, patch, prerelease=(), build=()) -> None| Parameter | Type | Description |
|---|---|---|
major | int | |
minor | int | |
patch | int | |
prerelease | tuple[Identifier, ...] = () | |
build | tuple[str, ...] = () |
format#
format() -> strMAJOR.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 outis_prerelease#
is_prerelease() -> boolReturns bool
def is_prerelease(self) -> bool:
return bool(self.prerelease)has_build#
has_build() -> boolReturns bool
def has_build(self) -> bool:
return bool(self.build)is_initial_development#
is_initial_development() -> boolWhether the major version is 0.
Returns bool
def is_initial_development(self) -> bool:
"""Whether the major version is 0."""
return self.major == 0with_prerelease#
with_prerelease(prerelease) -> SemVer| Parameter | Type | Description |
|---|---|---|
prerelease | Sequence[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| Parameter | Type | Description |
|---|---|---|
build | Sequence[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() -> SemVerThe 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() -> SemVerReturns 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() -> SemVerReturns 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() -> SemVerReturns 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| Parameter | Type | Description |
|---|---|---|
identifier | str | 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| Parameter | Type | Description |
|---|---|---|
identifier | str | 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| Parameter | Type | Description |
|---|---|---|
identifier | str | 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| Parameter | Type | Description |
|---|---|---|
identifier | str | 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) -> SemVerThe next version of release_type, as npm's semver.inc.
| Parameter | Type | Description |
|---|---|---|
release_type | ReleaseType | |
identifier | str | 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 | NoneThe release type between the two versions, as npm's
semver.diff; None when they have the same precedence.
| Parameter | Type | Description |
|---|---|---|
that | SemVer |
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"