Skip to content

Version

sereto.models.version

ProjectVersion

Bases: RootModel[VersionVPrefixPydanticAnnotation]

Source code in sereto/models/version.py
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
@total_ordering
class ProjectVersion(RootModel[VersionVPrefixPydanticAnnotation]):
    root: VersionVPrefixPydanticAnnotation

    @field_validator("root", mode="after")
    @classmethod
    def prerelease_build_not_set(cls, v: Version) -> Version:
        if v.prerelease is not None or v.build is not None or v.patch != 0:
            raise ValueError("only major, minor parts are supported")
        return v

    @model_serializer()
    def serialize_model(self) -> str:
        return self.__str__()

    def __lt__(self, other: Any) -> bool:
        if type(self) is not type(other):
            raise SeretoTypeError("incompatible types for comparison")
        return self.root < other.root

    def __eq__(self, other: Any) -> bool:
        if type(self) is not type(other):
            raise SeretoTypeError("incompatible types for comparison")
        return self.root == other.root

    def __hash__(self) -> int:
        return self.root.__hash__()

    def __str__(self) -> str:
        return f"v{self.root.major}.{self.root.minor}"

    @classmethod
    def from_str(cls, v: str) -> Self:
        """Create a ProjectVersion instance from a string.

        Args:
            v: The string representation of the version, e.g. "v2.0".

        Returns:
            A validated ProjectVersion instance.
        """
        return cls.model_validate(VersionVPrefix.parse(v))

    def next_major_version(self) -> "ProjectVersion":
        return ProjectVersion.from_str(f"v{self.root.major + 1}.{self.root.minor}")

    def next_minor_version(self) -> "ProjectVersion":
        return ProjectVersion.from_str(f"v{self.root.major}.{self.root.minor + 1}")

    @property
    def path_suffix(self) -> str:
        return f"_{self.__str__()}" if self.root.major != 1 or self.root.minor != 0 else ""

from_str(v) classmethod

Create a ProjectVersion instance from a string.

Parameters:

Name Type Description Default
v str

The string representation of the version, e.g. "v2.0".

required

Returns:

Type Description
Self

A validated ProjectVersion instance.

Source code in sereto/models/version.py
195
196
197
198
199
200
201
202
203
204
205
@classmethod
def from_str(cls, v: str) -> Self:
    """Create a ProjectVersion instance from a string.

    Args:
        v: The string representation of the version, e.g. "v2.0".

    Returns:
        A validated ProjectVersion instance.
    """
    return cls.model_validate(VersionVPrefix.parse(v))

SeretoVersion

Bases: RootModel[VersionPydanticAnnotation]

Source code in sereto/models/version.py
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
@total_ordering
class SeretoVersion(RootModel[VersionPydanticAnnotation]):
    root: VersionPydanticAnnotation

    @field_validator("root", mode="after")
    @classmethod
    def prerelease_build_not_set(cls, v: Version) -> Version:
        if v.prerelease is not None or v.build is not None:
            raise ValueError("only major, minor, patch parts supported")
        return v

    @model_serializer()
    def serialize_model(self) -> str:
        return self.__str__()

    def __str__(self) -> str:
        return self.root.__str__()

    def __lt__(self, other: Any) -> bool:
        if type(self) is not type(other):
            raise SeretoTypeError("incompatible types for comparison")
        return self.root < other.root

    def __eq__(self, other: Any) -> bool:
        if type(self) is not type(other):
            raise SeretoTypeError("incompatible types for comparison")
        return self.root == other.root

    def __hash__(self) -> int:
        return self.root.__hash__()

    @classmethod
    def from_str(cls, v: str) -> Self:
        """Create a SeretoVersion instance from a string.

        Args:
            v: The string representation of the version, e.g. "1.2.3".

        Returns:
            A validated SeretoVersion instance.
        """
        return cls.model_validate(Version.parse(v))

from_str(v) classmethod

Create a SeretoVersion instance from a string.

Parameters:

Name Type Description Default
v str

The string representation of the version, e.g. "1.2.3".

required

Returns:

Type Description
Self

A validated SeretoVersion instance.

Source code in sereto/models/version.py
89
90
91
92
93
94
95
96
97
98
99
@classmethod
def from_str(cls, v: str) -> Self:
    """Create a SeretoVersion instance from a string.

    Args:
        v: The string representation of the version, e.g. "1.2.3".

    Returns:
        A validated SeretoVersion instance.
    """
    return cls.model_validate(Version.parse(v))

VersionVPrefix

Bases: Version

A subclass of Version which allows a "v" prefix.

Source code in sereto/models/version.py
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
class VersionVPrefix(Version):
    """A subclass of Version which allows a "v" prefix."""

    @classmethod
    def parse(cls, v: str) -> "Version":  # type: ignore[override]  # ty: ignore[incompatible-method-override]
        """Parse version string to a Version instance.

        Args:
            v: version string with "v" prefix

        Raises:
            ValueError: when version does not start with "v"

        Returns:
            A new Version instance
        """
        if len(v) == 0 or v[0] != "v" or len(v.split(".")) != 2:
            raise ValueError("invalid format: use vMAJOR.MINOR")
        return Version.parse(v[1:], optional_minor_and_patch=True)

    def __str__(self) -> str:
        return f"v{super().__str__()}"

parse(v) classmethod

Parse version string to a Version instance.

Parameters:

Name Type Description Default
v str

version string with "v" prefix

required

Raises:

Type Description
ValueError

when version does not start with "v"

Returns:

Type Description
Version

A new Version instance

Source code in sereto/models/version.py
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
@classmethod
def parse(cls, v: str) -> "Version":  # type: ignore[override]  # ty: ignore[incompatible-method-override]
    """Parse version string to a Version instance.

    Args:
        v: version string with "v" prefix

    Raises:
        ValueError: when version does not start with "v"

    Returns:
        A new Version instance
    """
    if len(v) == 0 or v[0] != "v" or len(v.split(".")) != 2:
        raise ValueError("invalid format: use vMAJOR.MINOR")
    return Version.parse(v[1:], optional_minor_and_patch=True)