semantic-version-tools 1.4.0__tar.gz → 1.5.0__tar.gz

semantic_version_tools-1.5.0/CHANGELOG.md

@@ -0,0 +1,39 @@
+# Version-Tools Changelog
+
+## Version 1.5.0 (2026-11-09)
+
+- Support and test Python 3.10 through 3.15.
+- Use uv for dependency management and builds, with Ruff for linting and formatting.
+- Validate complete version strings, preserve build metadata and accept prereleases with an omitted patch.
+- Return a new version from addition. Augmented assignment rebinds the left-hand variable.
+- Add regression tests and an 80% coverage threshold to the documented test command.
+
+## Version 1.4.0 (2025-10-22)
+
+- test for python 3.14
+
+## Version 1.3.2 (2025-09-25)
+
+- update of dependencies
+
+## Version 1.3.1 (2025-03-03)
+
+- add the \_\_add__ method
+- improve documentation
+
+## Version 1.3.0 (2025-02-25)
+
+- Moved to standalone module
+- Add tests
+
+## Version 1.2.0 (2024-11-18)
+
+- accept string as imput
+
+## Version 1.1.0 (2024-10-04) 
+
+- The patch is now not mandatory
+
+## Version 1.0.0 (2021-09-07)
+
+- First implementation of the class

semantic_version_tools-1.5.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.3
+Name: semantic-version-tools
+Version: 1.5.0
+Summary: Class to manage semantic versioning
+Author: Romolo Politi
+Author-email: Romolo Politi <romolo.politi@inaf.it>
+Requires-Python: >=3.10, <3.16
+Description-Content-Type: text/markdown
+
+# Version-Tools
+
+`semantic-version-tools` provides `Vers`, a Python class for parsing,
+comparing and incrementing version numbers. It supports Python 3.10–3.15.
+
+## Installation
+
+Install from PyPI with pip or add the package to a uv project.
+
+```sh
+pip install semantic-version-tools
+uv add semantic-version-tools
+```
+
+## Usage
+
+```pycon
+>>> from semantic_version_tools import Vers
+>>> Vers("1.2")
+Version 1.2
+>>> Vers((1, 2, 0, "d", 1))
+Version 1.2.0-devel.1
+>>> Vers("1.2-dev.1+sha.abc").full()
+'1.2.0-devel.1+sha.abc'
+>>> Vers("1.2.0-rc.1") < Vers("1.2.0")
+True
+```
+
+Tuples contain two to five fields in this order: major, minor, patch,
+prerelease code and build number. The prerelease codes are `d` (development),
+`a` (alpha), `b` (beta), `rc` (release candidate) and `f` (final).
+A prerelease string with an omitted patch uses patch zero. Metadata after
+`+` is preserved in the full version and ignored in comparisons.
+`short()` returns the numeric version without the prerelease or metadata.
+
+Addition returns a new `Vers` instance. Integers increment the minor
+component. Floats use the integer and fractional digits as major and minor
+increments. Adding another `Vers` combines the numeric components and
+preserves the left operand's precision and release information.
+
+```pycon
+>>> current = Vers("1.2.3")
+>>> current + 1
+Version 1.3.3
+>>> current + 1.2
+Version 2.4.3
+>>> current
+Version 1.2.3
+>>> current += Vers("1.0.1")
+>>> current
+Version 2.2.4
+```
+
+## Development
+
+```sh
+git clone https://github.com/RomoloPoliti-INAF/version-tools.git
+cd version-tools
+uv sync --locked
+uv run --locked ruff check
+uv run --locked ruff format --check
+uv run --locked pytest --cov=semantic_version_tools --cov-branch --cov-report=term-missing --cov-fail-under=80
+uv build
+```

semantic_version_tools-1.5.0/README.md

@@ -0,0 +1,64 @@
+# Version-Tools
+
+`semantic-version-tools` provides `Vers`, a Python class for parsing,
+comparing and incrementing version numbers. It supports Python 3.10–3.15.
+
+## Installation
+
+Install from PyPI with pip or add the package to a uv project.
+
+```sh
+pip install semantic-version-tools
+uv add semantic-version-tools
+```
+
+## Usage
+
+```pycon
+>>> from semantic_version_tools import Vers
+>>> Vers("1.2")
+Version 1.2
+>>> Vers((1, 2, 0, "d", 1))
+Version 1.2.0-devel.1
+>>> Vers("1.2-dev.1+sha.abc").full()
+'1.2.0-devel.1+sha.abc'
+>>> Vers("1.2.0-rc.1") < Vers("1.2.0")
+True
+```
+
+Tuples contain two to five fields in this order: major, minor, patch,
+prerelease code and build number. The prerelease codes are `d` (development),
+`a` (alpha), `b` (beta), `rc` (release candidate) and `f` (final).
+A prerelease string with an omitted patch uses patch zero. Metadata after
+`+` is preserved in the full version and ignored in comparisons.
+`short()` returns the numeric version without the prerelease or metadata.
+
+Addition returns a new `Vers` instance. Integers increment the minor
+component. Floats use the integer and fractional digits as major and minor
+increments. Adding another `Vers` combines the numeric components and
+preserves the left operand's precision and release information.
+
+```pycon
+>>> current = Vers("1.2.3")
+>>> current + 1
+Version 1.3.3
+>>> current + 1.2
+Version 2.4.3
+>>> current
+Version 1.2.3
+>>> current += Vers("1.0.1")
+>>> current
+Version 2.2.4
+```
+
+## Development
+
+```sh
+git clone https://github.com/RomoloPoliti-INAF/version-tools.git
+cd version-tools
+uv sync --locked
+uv run --locked ruff check
+uv run --locked ruff format --check
+uv run --locked pytest --cov=semantic_version_tools --cov-branch --cov-report=term-missing --cov-fail-under=80
+uv build
+```

semantic_version_tools-1.5.0/pyproject.toml

@@ -0,0 +1,45 @@
+[project]
+name = "semantic-version-tools"
+version = "1.5.0"
+description = "Class to manage semantic versioning"
+readme = "README.md"
+requires-python = ">=3.10,<3.16"
+dependencies = []
+
+[[project.authors]]
+name = "Romolo Politi"
+email = "romolo.politi@inaf.it"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.2.0,<10",
+    "pytest-cov>=7,<8",
+    "ruff>=0.17.4",
+]
+
+[build-system]
+requires = ["uv_build>=0.13.7,<0.14"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+source-include = ["CHANGELOG.md"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 88
+src = ["src"]
+
+[tool.ruff.lint]
+select = [
+    "E4",
+    "E7",
+    "E9",
+    "F",
+    "I",
+    "UP",
+    "B",
+    "RUF",
+]
+
+[tool.ruff.format]
+docstring-code-format = true

semantic_version_tools-1.5.0/pyproject.toml.orig

@@ -0,0 +1,35 @@
+[project]
+name = "semantic-version-tools"
+version = "1.5.0"
+description = "Class to manage semantic versioning"
+authors = [
+    {name = "Romolo Politi",email = "romolo.politi@inaf.it"}
+]
+readme = "README.md"
+requires-python = ">=3.10,<3.16"
+dependencies = []
+
+[dependency-groups]
+dev = [
+    "pytest>=9.2.0,<10",
+    "pytest-cov>=7,<8",
+    "ruff>=0.17.4",
+]
+
+[build-system]
+requires = ["uv_build>=0.13.7,<0.14"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+source-include = ["CHANGELOG.md"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 88
+src = ["src"]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F", "I", "UP", "B", "RUF"]
+
+[tool.ruff.format]
+docstring-code-format = true

semantic_version_tools-1.5.0/src/semantic_version_tools/__init__.py

@@ -0,0 +1 @@
+from semantic_version_tools.version import Vers as Vers

semantic_version_tools-1.5.0/src/semantic_version_tools/version.py

@@ -0,0 +1,158 @@
+import re
+from copy import copy
+from functools import total_ordering
+from importlib.metadata import version
+
+###################################
+# Versioning Class
+###################################
+#
+# This class is used to manage the versioning of the
+# software or other products
+#
+# The versioning is based on the Semantic Versioning 2.0.0
+#
+
+
+__version__ = version("semantic_version_tools")
+
+code = {"d": "devel", "a": "alpha", "b": "beta", "rc": "ReleaseCandidate", "f": "Final"}
+
+numeric_map = {"d": 1, "a": 2, "b": 3, "rc": 4, "f": 5}
+
+
+@total_ordering
+class Vers:
+    """
+    Class for the manipulation of objects version following the Semantic Versioning
+
+    major.minor.patch-<prerel>.<build>
+
+    Is implemented a special dialect.
+
+
+
+    The admitted pre-release values are
+
+        * d  for the developing version
+        * a  for the alpha version
+        * b  for the beta version
+        * rc for the release candidate
+        * f  for the final version
+    """
+
+    def __init__(self, ver: tuple | str) -> None:
+
+        self.metadata = None
+        if isinstance(ver, str):
+            match = re.fullmatch(
+                r"(\d+)\.(\d+)(?:\.(\d+))?"
+                r"(?:[-.]([a-zA-Z]+)(?:\.?(\d+))?)?"
+                r"(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?",
+                ver,
+            )
+            if match is None:
+                raise ValueError(f"Invalid version: {ver!r}")
+
+            major, minor, patch, release, build, self.metadata = match.groups()
+            ver = (int(major), int(minor))
+            if patch is not None or release is not None:
+                ver += (int(patch or 0),)
+            if release is not None:
+                aliases = {
+                    "dev": "d",
+                    "development": "d",
+                    **{name.lower(): key for key, name in code.items()},
+                }
+                release = release.lower()
+                ver += (aliases.get(release, release), int(build or 1))
+
+        if not isinstance(ver, tuple):
+            raise TypeError("Version must be a string or tuple")
+        if not 2 <= len(ver) <= 5:
+            raise ValueError("Version tuple must contain two to five elements")
+
+        self.major, self.minor = ver[:2]
+        self._len = min(len(ver), 3)
+        self.patch = ver[2] if len(ver) >= 3 else 0
+        self.type = ver[3] if len(ver) >= 4 else "f"
+        self.build = ver[4] if len(ver) == 5 else 1
+        if self.type is not None:
+            if not isinstance(self.type, str):
+                raise TypeError(
+                    "The fourth element of the version number must be a string"
+                )
+            if self.type not in code:
+                raise ValueError(
+                    f"The fourth element of the version must be one of {','.join(code)}"
+                )
+
+    def full(self) -> str:
+        """
+        Return the full version
+
+        Returns:
+            str: the version string
+        """
+        if self.type is None or self.type.lower() == "f":
+            nVer = self.short()
+        # elif:
+        #     nVer = f"{self.major}.{self.minor}.{self.patch}"
+        else:
+            nVer = (
+                f"{self.major}.{self.minor}.{self.patch}-{code[self.type]}.{self.build}"
+            )
+        if self.metadata is not None:
+            return f"{nVer}+{self.metadata}"
+        return nVer
+
+    def short(self) -> str:
+        """
+        Return the version in the form major.minor.patch
+
+        Returns:
+            str: the version string
+        """
+        return f"{self.major}.{self.minor}{f'.{self.patch}' if self._len == 3 else ''}"
+
+    def __repr__(self) -> str:
+        return f"Version {self.full()}"
+
+    def __str__(self) -> str:
+        return f"Version {self.full()}"
+
+    def _precedence(self) -> tuple:
+        return (
+            self.major,
+            self.minor,
+            self.patch,
+            numeric_map[self.type or "f"],
+            self.build,
+        )
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, Vers):
+            return NotImplemented
+        return self._precedence() == other._precedence()
+
+    def __lt__(self, other) -> bool:
+        if not isinstance(other, Vers):
+            return NotImplemented
+        return self._precedence() < other._precedence()
+
+    def __add__(self, other: "Vers | int | float") -> "Vers":
+        result = copy(self)
+        if isinstance(other, int):
+            result.minor += other
+        elif isinstance(other, float):
+            major, minor = str(other).split(".")
+            result.major += int(major)
+            result.minor += int(minor)
+        elif isinstance(other, Vers):
+            result.major += other.major
+            result.minor += other.minor
+            if result._len == 3:
+                result.patch += other.patch
+        else:
+            return NotImplemented
+        return result

semantic_version_tools-1.4.0/PKG-INFO

@@ -1,137 +0,0 @@
-Metadata-Version: 2.3
-Name: semantic-version-tools
-Version: 1.4.0
-Summary: Class to manage semantic versioning
-Author: Romolo Politi
-Author-email: romolo.politi@inaf.it
-Requires-Python: >=3.10,<3.15
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: setuptools (>=80.9.0,<81.0.0)
-Description-Content-Type: text/markdown
-
-
-# Version-Tools
-
-## Installation
-
-### From Repository
-
-To install the Version-Tools package from the repository, run the following commands:
-
-```sh
-git clone https://github.com/RomoloPoliti-INAF/version-tools.git
-cd version-tools
-poetry install
-```
-
-### From PyPi
-
-To install the Version-Tools package from PyPi, run the following command:
-
-```sh
-pip install semantic-version-tools
-```
-### Using poetry
-
-To add the package to your poetry project, you can run the command:
-
-```sh
-poetry add semantic-versioning-tools
-```
-
-
-## Usage
-
-To use the library it's necessary import the class *Vers*, than you can comapare or manipulate the version numbers.
-
-### Initialize and print version
-
-```python
->>> from semantic_version_tools import Vers
-
->>> main_ver=Vers('1.0')
->>> print(main_ver)
-
-Version 1.0
-```
-
-The version number could be a string or a tuple, whit 2 or 5 elements:
-- the major version number
-- the minor version number
-- the patch number
-- pre-release type
-- build number
-
-For the pre-release are used letters as reported below:
-
-- **d**: developing version
-- **a**: alpha release
-- **b**: beta release
-- **rc**: release candidate
-- **f**: final release
-
-```python
->>> main_version = Vers((0,1,0,'d',1))
->>> print(main_version)
-
-Version 0.1.0-devel.1
-
->>> main_version = Vers('0.1.0-a.1')
->>> print(main_version)
-
-Version 0.1.0-alpha.1
-```
-
-### Compare versions
-
-In the class Vers are implemented the main comparison operators.
-For example:
-
-```python
->>> a=Vers('1.0.0')
->>> b=Vers('1.0.1')
-
->>> a>b
-False
->>> a==b
-False
->>> a<b
-True
-a<=b
-True
-```
-
-### Sum and increase
-
-It's possible sum tro version number or icrease it.
-
-```python
->>> a = Vers('1.0.0')
->>> b = Vers('1.0.1')
->>> c=a+b
->>> c
-Version 2.0.1
-
-
->>> a = Vers('1.0.0')
->>> a=a+1
->>> a
-Version 1.1.0
-# equivalent to
->>> a +=1
->>> a
-Version 1.1.0
-```
-
-The summ add a minor version. To add a major version you must add a float
-
-```python
->>> a = Vers('1.0.0')
->>> a += 1.0
->>> a
-Version 2.0.0
-```

semantic_version_tools-1.4.0/README.md

@@ -1,122 +0,0 @@
-
-# Version-Tools
-
-## Installation
-
-### From Repository
-
-To install the Version-Tools package from the repository, run the following commands:
-
-```sh
-git clone https://github.com/RomoloPoliti-INAF/version-tools.git
-cd version-tools
-poetry install
-```
-
-### From PyPi
-
-To install the Version-Tools package from PyPi, run the following command:
-
-```sh
-pip install semantic-version-tools
-```
-### Using poetry
-
-To add the package to your poetry project, you can run the command:
-
-```sh
-poetry add semantic-versioning-tools
-```
-
-
-## Usage
-
-To use the library it's necessary import the class *Vers*, than you can comapare or manipulate the version numbers.
-
-### Initialize and print version
-
-```python
->>> from semantic_version_tools import Vers
-
->>> main_ver=Vers('1.0')
->>> print(main_ver)
-
-Version 1.0
-```
-
-The version number could be a string or a tuple, whit 2 or 5 elements:
-- the major version number
-- the minor version number
-- the patch number
-- pre-release type
-- build number
-
-For the pre-release are used letters as reported below:
-
-- **d**: developing version
-- **a**: alpha release
-- **b**: beta release
-- **rc**: release candidate
-- **f**: final release
-
-```python
->>> main_version = Vers((0,1,0,'d',1))
->>> print(main_version)
-
-Version 0.1.0-devel.1
-
->>> main_version = Vers('0.1.0-a.1')
->>> print(main_version)
-
-Version 0.1.0-alpha.1
-```
-
-### Compare versions
-
-In the class Vers are implemented the main comparison operators.
-For example:
-
-```python
->>> a=Vers('1.0.0')
->>> b=Vers('1.0.1')
-
->>> a>b
-False
->>> a==b
-False
->>> a<b
-True
-a<=b
-True
-```
-
-### Sum and increase
-
-It's possible sum tro version number or icrease it.
-
-```python
->>> a = Vers('1.0.0')
->>> b = Vers('1.0.1')
->>> c=a+b
->>> c
-Version 2.0.1
-
-
->>> a = Vers('1.0.0')
->>> a=a+1
->>> a
-Version 1.1.0
-# equivalent to
->>> a +=1
->>> a
-Version 1.1.0
-```
-
-The summ add a minor version. To add a major version you must add a float
-
-```python
->>> a = Vers('1.0.0')
->>> a += 1.0
->>> a
-Version 2.0.0
-```

semantic_version_tools-1.4.0/pyproject.toml

@@ -1,33 +0,0 @@
-[project]
-name = "semantic-version-tools"
-version = "1.4.0"
-description = "Class to manage semantic versioning"
-authors = [
-    {name = "Romolo Politi",email = "romolo.politi@inaf.it"}
-]
-readme = "README.md"
-dependencies = [
-    "setuptools (>=80.9.0,<81.0.0)"
-]
-
-
-[tool.poetry]
-packages = [{include = "semantic_version_tools", from = "src"}]
-include = ["CHANGELOG.md"]
-name="semantic-version-tools"
-version="1.3.1"
-description="Class to manage semantic versioning"
-authors = [
-    "Romolo Politi <romolo.politi@inaf.it>"
-]
-
-[tool.poetry.dependencies]
-python = ">=3.10, <3.15"
-
-
-[tool.poetry.group.dev.dependencies]
-pytest = "^8.3.4"
-
-[build-system]
-requires = ["poetry-core>=2.0.0,<3.0.0"]
-build-backend = "poetry.core.masonry.api"

semantic_version_tools-1.4.0/src/semantic_version_tools/__init__.py

@@ -1 +0,0 @@
-from semantic_version_tools.version import Vers

semantic_version_tools-1.4.0/src/semantic_version_tools/version.py

@@ -1,198 +0,0 @@
-
-import re
-from importlib.metadata import version
-
-
-###################################
-# Versioning Class
-###################################
-#
-# This class is used to manage the versioning of the
-# software or other products
-#
-# The versioning is based on the Semantic Versioning 2.0.0
-#
-
-
-__version__ = version('semantic_version_tools')
-
-code = {"d": "devel", "a": "alpha", "b": "beta", "rc": "ReleaseCandidate", "f": "Final"}
-
-numeric_map = {"d": 1, "a": 2, "b": 3, "rc": 4, "f": 5}
-
-
-class Vers:
-    """
-    Class for the manipulation of objects version following the Semantic Versioning
-
-    major.minor.patch-<prerel>.<build>
-
-    Is implemented a special dialect.
-
-
-
-    The admitted pre-release values are
-
-        * d  for the developing version
-        * a  for the alpha version
-        * b  for the beta version
-        * rc for the release candidate
-        * f  for the final version
-    """
-
-    def __init__(self, ver: tuple | str) -> None:
-
-        if isinstance(ver, str):
-            a = re.match(
-                r"(\d+)\.(\d+)(?:\.(\d+))?(?:[-\.]([a-zA-Z]*)(?:\.?(\d+))?)?", ver
-            )
-            prt = list(a.groups())
-            prt[0:2] = [int(i) for i in prt[0:2]]
-            if prt[2] is not None:
-                prt[2] = int(prt[2])
-            if prt[3] is not None:
-                if prt[3].lower() in "development":
-                    prt[3] = "d"
-                elif prt[3].lower() in "alpha":
-                    prt[3] = "a"
-                elif prt[3].lower() in "beta":
-                    prt[3] = "b"
-                elif prt[3].lower() in "releasecandidate":
-                    prt[3] = "rc"
-                elif prt[3].lower() in "final":
-                    prt[3] = "f"
-            else:
-                prt[3] = None
-            if prt[3] is not None and prt[4] is None:
-                prt[4] = None
-            else:
-                if prt[3] is not None:
-                    prt[4] = int(prt[4])
-            ver = tuple([x for x in prt if x is not None])
-        # print(ver)
-        self._len = 3
-        if len(ver) < 3:
-            self.major, self.minor, *extra = ver
-            self.patch = 0
-            self._len = 2
-        else:
-            self.major, self.minor, self.patch, *extra = ver
-        # self.patch = extra[0] if extra else None
-        self.type = extra[0] if len(extra) != 0 else 'f'
-        if self.type is not None:
-            if not isinstance(self.type, str):
-                raise Exception(
-                    f"The fourth element of the version number must be a string"
-                )
-            if not self.type in code.keys():
-                raise ValueError(
-                    f"the fourth element of the version mus be one of {
-                                ','.join(code.keys())}"
-                )
-        self.build = extra[1] if len(extra) > 1 else 1
-
-    def full(self) -> str:
-        """
-        Return the full version
-
-        Returns:
-            str: the version string
-        """
-        if self.type is None or self.type.lower() == "f":
-            nVer = f"{self.major}.{self.minor}{
-                f'.{self.patch}' if self._len == 3 else ''}"
-        # elif:
-        #     nVer = f"{self.major}.{self.minor}.{self.patch}"
-        else:
-            nVer = f"{self.major}.{self.minor}.{
-                self.patch}-{code[self.type]}.{self.build}"
-        return nVer
-
-    def short(self) -> str:
-        """
-        Return the version in the form major.minor.patch
-
-        Returns:
-            str: the version string
-        """
-        return f"{self.major}.{self.minor}{f'.{self.patch}' if self._len==3 else ''}"
-
-    def __repr__(self) -> str:
-        return f"Version {self.full()}"
-
-    def __str__(self) -> str:
-        return f"Version {self.full()}"
-
-    def __eq__(self, other) -> bool:
-        if (
-            self.major == other.major
-            and self.minor == other.minor
-            and self.patch == other.patch
-        ):
-            if self.type is None:
-                return True
-            else:
-                if self.type == other.type and self.build == other.build:
-                    return True
-                else:
-                    return False
-        else:
-            return False
-        # return all(getattr(self, item) == getattr(other, item) for item in self.__dict__ if not item.startswith('_'))
-
-    def __ne__(self, other) -> bool:
-        return not self == other
-
-    def __gt__(self, other) -> bool:
-        if self.major != other.major:
-            return self.major > other.major
-        elif self.minor != other.minor:
-            return self.minor > other.minor
-        elif self.patch != other.patch:
-            return self.patch > other.patch
-        elif numeric_map[self.type] != numeric_map[other.type]:
-            return numeric_map[self.type] > numeric_map[other.type]
-        else:
-            return self.build > other.build
-
-    def __ge__(self, other) -> bool:
-        if self > other or self == other:
-            return True
-        else:
-            return False
-
-    def __lt__(self, other) -> bool:
-        if self.major != other.major:
-            return self.major < other.major
-        elif self.minor != other.minor:
-            return self.minor < other.minor
-        elif self.patch != other.patch:
-            return self.patch < other.patch
-        elif numeric_map[self.type] != numeric_map[other.type]:
-            return numeric_map[self.type] < numeric_map[other.type]
-        else:
-            return self.build < other.build
-
-    def __le__(self, other) -> bool:
-        if self < other or self == other:
-            return True
-        else:
-            return False
-
-    def __add__(self, other:"Vers") -> "Vers":
-        
-        if isinstance(other,int):
-            self.minor += other
-            
-        if isinstance(other,float):
-            a=str(other).split(".")
-            self.major += int(a[0])
-            self.minor += int(a[1])
-            
-        if isinstance(other, Vers):
-            self.major += other.major
-            self.minor += other.minor
-            if self._len == 3:
-                self.patch += other.patch
-        return self
-# version = Vers(VERSION)