version-query 1.6.1__tar.gz → 1.6.2__tar.gz

{version_query-1.6.1/version_query.egg-info → version_query-1.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: version-query
-Version: 1.6.1
+Version: 1.6.2
 Summary: Zero-overhead package versioning for Python.
 Home-page: https://github.com/mbdevpl/version-query
 Download-URL: 
@@ -81,7 +81,7 @@ Zero-overhead package versioning for Python.
     :alt: grade from Codacy
 
 .. image:: https://img.shields.io/github/license/mbdevpl/version-query.svg
-    :target: https://github.com/mbdevpl/version-query/blob/v1.6.1/NOTICE
+    :target: https://github.com/mbdevpl/version-query/blob/v1.6.2/NOTICE
     :alt: license
 
 Package versioning toolkit for Python which relies on git tags, git history traversal
@@ -361,9 +361,9 @@ Incrementing any version component clears all existing following components.
 Examples of how version is incremented:
 
 *   for ``1.5``, incrementing ``<major>`` results in ``2.0``;
-*   for ``1.5.1-2.4``, ``<minor>``++ results in ``1.6``;
-*   ``1.5.1-2.4``, ``<patch>``++, ``1.5.2``;
-*   ``1.5.1``, ``<major>``+=3, ``4.0.0``.
+*   for ``1.5.1-2.4``, ``<minor>`` ++ results in ``1.6``;
+*   ``1.5.1-2.4``, ``<patch>`` ++, ``1.5.2``;
+*   ``1.5.1``, ``<major>`` += 3, ``4.0.0``.
 
 
 API details
@@ -491,8 +491,8 @@ Requirements
 
 Python version 3.9 or later.
 
-Python libraries as specified in `requirements.txt <https://github.com/mbdevpl/version-query/blob/v1.6.1/requirements.txt>`_.
+Python libraries as specified in `requirements.txt <https://github.com/mbdevpl/version-query/blob/v1.6.2/requirements.txt>`_.
 
-Building and running tests additionally requires packages listed in `requirements_test.txt <https://github.com/mbdevpl/version-query/blob/v1.6.1/requirements_test.txt>`_.
+Building and running tests additionally requires packages listed in `requirements_test.txt <https://github.com/mbdevpl/version-query/blob/v1.6.2/requirements_test.txt>`_.
 
 Tested on Linux, macOS and Windows.

{version_query-1.6.1 → version_query-1.6.2}/README.rst

@@ -308,9 +308,9 @@ Incrementing any version component clears all existing following components.
 Examples of how version is incremented:
 
 *   for ``1.5``, incrementing ``<major>`` results in ``2.0``;
-*   for ``1.5.1-2.4``, ``<minor>``++ results in ``1.6``;
-*   ``1.5.1-2.4``, ``<patch>``++, ``1.5.2``;
-*   ``1.5.1``, ``<major>``+=3, ``4.0.0``.
+*   for ``1.5.1-2.4``, ``<minor>`` ++ results in ``1.6``;
+*   ``1.5.1-2.4``, ``<patch>`` ++, ``1.5.2``;
+*   ``1.5.1``, ``<major>`` += 3, ``4.0.0``.
 
 
 API details

{version_query-1.6.1 → version_query-1.6.2}/test/test_version.py

@@ -25,19 +25,21 @@ class Tests(unittest.TestCase):
             with self.subTest(version_str=version_str, version_tuple=version_tuple):
 
                 py_version = \
-                    pkg_resources.parse_version(version_str)  # type: packaging.version.Version
-                # self.assertIsInstance(
-                #     py_version, packaging.version.Version, msg=(type(py_version), py_version))
+                    pkg_resources.parse_version(version_str)
                 _LOG.debug('packaging parsed version string %s into %s: %s',
                            repr(version_str), type(py_version), py_version)
+                # self.assertIsInstance(
+                #     py_version, packaging.version.Version, msg=(type(py_version), py_version))
 
                 try:
-                    sem_version = semver.VersionInfo.parse(version_str)  # type: semver.VersionInfo
+                    sem_version = semver.VersionInfo.parse(version_str)
                 except ValueError:
                     _LOG.debug('semver could not parse version string %s', repr(version_str))
                 else:
                     _LOG.debug('semver parsed version string %s into %s: %s',
                                repr(version_str), type(sem_version), sem_version)
+                # self.assertIsInstance(
+                #     sem_version, semver.VersionInfo, msg=(type(sem_version), sem_version))
 
                 self.assertEqual(Version.from_str(version_str).to_tuple(), version_tuple)
 
@@ -76,7 +78,7 @@ class Tests(unittest.TestCase):
             version_tuple = case_to_version_tuple(args, kwargs)
             with self.subTest(version_str=version_str, version_tuple=version_tuple):
                 try:
-                    sem_version = semver.VersionInfo.parse(version_str)  # type: semver.VersionInfo
+                    sem_version = semver.VersionInfo.parse(version_str)
                 except ValueError:
                     continue
                 else:
@@ -123,6 +125,7 @@ class Tests(unittest.TestCase):
                     self.assertIsInstance(version.local, tuple)
 
     def test_init_bad(self):
+        # pylint: disable = redefined-variable-type
         for (args, kwargs), exception in BAD_INIT_CASES.items():
             with self.subTest(args=args, kwargs=kwargs, exception=exception):
                 with self.assertRaises(exception):

{version_query-1.6.1 → version_query-1.6.2}/version_query/git_query.py

@@ -40,6 +40,17 @@ def _git_version_tags(repo: git.Repo) -> t.Mapping[git.Tag, Version]:
     return versions
 
 
+def _git_version_tag_commits(
+        version_tags: t.Iterable[git.Tag]) -> t.Mapping[git.objects.Commit, t.Set[git.Tag]]:
+    version_tag_commits: t.Dict[git.objects.Commit, t.Set[git.Tag]] = {}
+    for tag in version_tags:
+        _commit = tag.commit
+        if _commit not in version_tag_commits:
+            version_tag_commits[_commit] = set()
+        version_tag_commits[_commit].add(tag)
+    return version_tag_commits
+
+
 def _latest_git_version_tag_on_branches(
         repo: git.Repo, assume_if_none: bool, commit: git.objects.Commit, commit_distance: int,
         skip_commits: t.Set[git.objects.Commit]) -> t.Union[int, t.Tuple[
@@ -80,12 +91,7 @@ def _latest_git_version_tag(
             t.Optional[git.objects.Commit], t.Optional[git.TagReference], t.Optional[Version], int]:
     """Return (commit, tag at that commit if any, latest version, distance from the version)."""
     version_tags = _git_version_tags(repo)
-    version_tag_commits: t.Dict[git.objects.Commit, set] = {}
-    for tag, version in version_tags.items():
-        _commit = tag.commit
-        if _commit not in version_tag_commits:
-            version_tag_commits[_commit] = set()
-        version_tag_commits[_commit].add(tag)
+    version_tag_commits = _git_version_tag_commits(version_tags.keys())
     current_version_tags = {}
     commit = None
     if skip_commits is None:

version_query-1.6.2/version_query/parser.py

@@ -0,0 +1,53 @@
+"""Functions for parsing version strings into their components and verifying the format."""
+
+import logging
+import typing as t
+
+from . import patterns
+
+_LOG = logging.getLogger(__name__)
+
+
+def parse_release_str(release: str) -> tuple:
+    """Parse a release string into major, minor, and patch version numbers."""
+    match = patterns.RELEASE.fullmatch(release)
+    assert match is not None
+    major_match = match.group('major')
+    assert major_match is not None
+    major = int(major_match)
+    minor_match = match.group('minor')
+    if minor_match is not None:
+        minor = int(minor_match)
+    else:
+        minor = None
+    patch_match = match.group('patch')
+    if patch_match is not None:
+        patch = int(patch_match)
+    else:
+        patch = None
+    return major, minor, patch
+
+
+def parse_pre_release_str(pre_release: str) -> t.Sequence[
+        t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]]:
+    """Parse a pre-release string into a sequence of tuples."""
+    parts = patterns.PRE_RELEASE.findall(pre_release)
+    _LOG.debug('parsed pre-release string %s into %s', repr(pre_release), parts)
+    tuples = []
+    for part in parts:
+        match = patterns.PRE_RELEASE_PART.fullmatch(part)
+        assert match is not None
+        pre_patch_match = match.group('prepatch')
+        if pre_patch_match is not None:
+            pre_patch = int(pre_patch_match)
+        else:
+            pre_patch = None
+        tuples.append((match.group('preseparator'), match.group('pretype'), pre_patch))
+    return tuples
+
+
+def parse_local_str(local: str) -> tuple:
+    """Parse a local version suffix string into a sequence."""
+    match = patterns.LOCAL.fullmatch(local)
+    assert match is not None
+    return tuple(_ for _ in match.groups() if _ is not None)

version_query-1.6.2/version_query/patterns.py

@@ -0,0 +1,39 @@
+"""Patterns for recognising parts of version strings and parsing them."""
+
+import re
+
+# pylint: disable = consider-using-f-string
+
+_NUMBER = r'(?:0|[123456789][0123456789]*)'
+# _SHA = r'[0123456789abcdef]+'
+_LETTERS = r'(?:[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]+)'
+LETTERS = re.compile(_LETTERS)
+_ALPHANUMERIC = r'(?:[0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]+)'
+ALPHANUMERIC = re.compile(_ALPHANUMERIC)
+_SEP = r'(?:[\.-])'
+
+_RELEASE_PARTS = \
+    r'(?P<major>{n})(?:\.(?P<minor>{n}))?(?:\.(?P<patch>{n}))?'.format(n=_NUMBER)
+RELEASE = re.compile(_RELEASE_PARTS)
+
+_PRE_SEPARATOR = rf'(?P<preseparator>{_SEP})'
+_PRE_TYPE = rf'(?P<pretype>{_LETTERS})'
+_PRE_PATCH = rf'(?P<prepatch>{_NUMBER})'
+_PRE_RELEASE_PART = rf'{_PRE_SEPARATOR}?{_PRE_TYPE}?{_PRE_PATCH}?'
+PRE_RELEASE_PART = re.compile(_PRE_RELEASE_PART)
+_PRE_RELEASE_PARTS = r'(?:{0}{2})|(?:{0}?{1}{2}?)'.format(_SEP, _LETTERS, _NUMBER)
+PRE_RELEASE = re.compile(_PRE_RELEASE_PARTS)
+# PRE_RELEASE_CHECK = re.compile(rf'(?:{_PRE_RELEASE_PARTS})+')
+
+_LOCAL_SEPARATOR = rf'({_SEP})'
+_LOCAL_PART = rf'({_ALPHANUMERIC})'
+_LOCAL_PARTS = rf'\+{_LOCAL_PART}(?:{_LOCAL_SEPARATOR}{_LOCAL_PART})*'
+LOCAL = re.compile(_LOCAL_PARTS)
+
+
+_RELEASE = r'(?P<release>{n}(?:\.{n})?(?:\.{n})?)'.format(n=_NUMBER)
+_PRE_RELEASE = r'(?P<prerelease>(?:(?:{0}{2})|(?:{0}?{1}{2}?))+)'.format(_SEP, _LETTERS, _NUMBER)
+_LOCAL = r'(?P<local>\+{0}([\.-]{0})*)'.format(_ALPHANUMERIC)
+# _NAMED_PARTS_COUNT = 3 + 3
+_VERSION = rf'{_RELEASE}{_PRE_RELEASE}?{_LOCAL}?'
+VERSION = re.compile(_VERSION)

{version_query-1.6.1 → version_query-1.6.2}/version_query/version.py

@@ -4,12 +4,14 @@ import collections.abc
 import enum
 import itertools
 import logging
-import re
 import typing as t
 
 import packaging.version
 import semver
 
+from . import patterns
+from .parser import parse_release_str, parse_pre_release_str, parse_local_str
+
 _LOG = logging.getLogger(__name__)
 
 PY_PRE_RELEASE_INDICATORS = {'a', 'b', 'c', 'rc'}
@@ -19,6 +21,8 @@ PY_PRE_RELEASE_INDICATORS = {'a', 'b', 'c', 'rc'}
 class VersionComponent(enum.IntEnum):
     """Enumeration of standard version components."""
 
+    # pylint: disable = invalid-name
+
     Major = 1 << 1
     Minor = 1 << 2
     Patch = 1 << 3
@@ -29,96 +33,21 @@ class VersionComponent(enum.IntEnum):
 
 
 def _version_tuple_checker(version_tuple, flags):
-    return all([(_ is not None if flag else _ is None) for _, flag in zip(version_tuple, flags)])
+    return all((_ is not None if flag else _ is None) for _, flag in zip(version_tuple, flags))
 
 
-class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-methods
+class Version(collections.abc.Hashable):
     """For storing and manipulating version information.
 
     Definitions of acceptable version formats are provided in readme.
     """
 
-    _re_number = r'(?:0|[123456789][0123456789]*)'
-    # _re_sha = r'[0123456789abcdef]+'
-    _re_letters = r'(?:[abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]+)'
-    _pattern_letters = re.compile(_re_letters)
-    _re_alphanumeric = r'(?:[0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ]+)'
-    _pattern_alphanumeric = re.compile(_re_alphanumeric)
-    _re_sep = r'(?:[\.-])'
-
-    _re_release_parts = \
-        r'(?P<major>{n})(?:\.(?P<minor>{n}))?(?:\.(?P<patch>{n}))?'.format(n=_re_number)
-    _pattern_release = re.compile(_re_release_parts)
-
-    @classmethod
-    def _parse_release_str(cls, release: str) -> tuple:
-        match = cls._pattern_release.fullmatch(release)
-        assert match is not None
-        major_match = match.group('major')
-        assert major_match is not None
-        major = int(major_match)
-        minor_match = match.group('minor')
-        if minor_match is not None:
-            minor = int(minor_match)
-        else:
-            minor = None
-        patch_match = match.group('patch')
-        if patch_match is not None:
-            patch = int(patch_match)
-        else:
-            patch = None
-        return major, minor, patch
-
-    _re_pre_separator = rf'(?P<preseparator>{_re_sep})'
-    _re_pre_type = rf'(?P<pretype>{_re_letters})'
-    _re_pre_patch = rf'(?P<prepatch>{_re_number})'
-    _re_pre_release_part = rf'{_re_pre_separator}?{_re_pre_type}?{_re_pre_patch}?'
-    _pattern_pre_release_part = re.compile(_re_pre_release_part)
-    _re_pre_release_parts = r'(?:{0}{2})|(?:{0}?{1}{2}?)'.format(_re_sep, _re_letters, _re_number)
-    _pattern_pre_release = re.compile(_re_pre_release_parts)
-    _pattern_pre_release_check = re.compile(rf'(?:{_re_pre_release_parts})+')
-
-    @classmethod
-    def _parse_pre_release_str(cls, pre_release: str) -> t.Sequence[
-            t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]]:
-        parts = cls._pattern_pre_release.findall(pre_release)
-        _LOG.debug('parsed pre-release string %s into %s',
-                   repr(pre_release), parts)
-        tuples = []
-        for part in parts:
-            match = cls._pattern_pre_release_part.fullmatch(part)
-            assert match is not None
-            pre_patch_match = match.group('prepatch')
-            if pre_patch_match is not None:
-                pre_patch = int(pre_patch_match)
-            else:
-                pre_patch = None
-            tuples.append((match.group('preseparator'), match.group('pretype'), pre_patch))
-        return tuples
-
-    _re_local_separator = rf'({_re_sep})'
-    _re_local_part = rf'({_re_alphanumeric})'
-    _re_local_parts = rf'\+{_re_local_part}(?:{_re_local_separator}{_re_local_part})*'
-    _pattern_local = re.compile(_re_local_parts)
-
-    @classmethod
-    def _parse_local_str(cls, local: str) -> tuple:
-        match = cls._pattern_local.fullmatch(local)
-        assert match is not None
-        return tuple([_ for _ in match.groups() if _ is not None])
-
-    _re_release = r'(?P<release>{n}(?:\.{n})?(?:\.{n})?)'.format(n=_re_number)
-    _re_pre_release = r'(?P<prerelease>(?:(?:{0}{2})|(?:{0}?{1}{2}?))+)'.format(
-        _re_sep, _re_letters, _re_number)
-    _re_local = r'(?P<local>\+{0}([\.-]{0})*)'.format(_re_alphanumeric)
-    # _re_named_parts_count = 3 + 3
-    _re_version = rf'{_re_release}{_re_pre_release}?{_re_local}?'
-    _pattern_version = re.compile(_re_version)
+    # pylint: disable = too-many-public-methods, too-many-instance-attributes
 
     @classmethod
     def from_str(cls, version_str: str):
         """Create version from string."""
-        match = cls._pattern_version.fullmatch(version_str)  # type: t.Optional[t.Match[str]]
+        match = patterns.VERSION.fullmatch(version_str)  # type: t.Optional[t.Match[str]]
         if match is None:
             raise ValueError(f'version string {repr(version_str)} is invalid')
         _LOG.debug('version_query parsed version string %s into %s: %s %s',
@@ -128,9 +57,9 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
         _pre_release = match.group('prerelease')
         _local = match.group('local')
 
-        major, minor, patch = cls._parse_release_str(_release)
-        pre_release = None if _pre_release is None else cls._parse_pre_release_str(_pre_release)
-        local = None if _local is None else cls._parse_local_str(_local)
+        major, minor, patch = parse_release_str(_release)
+        pre_release = None if _pre_release is None else parse_pre_release_str(_pre_release)
+        local = None if _local is None else parse_local_str(_local)
 
         return cls(major=major, minor=minor, patch=patch, pre_release=pre_release, local=local)
 
@@ -147,13 +76,13 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
         """Create version from a standard Python version object."""
         if not isinstance(py_version, packaging.version.Version):
             _LOG.warning('attempting to parse %s as packaging.version.Version...', type(py_version))
-        ver = py_version._version
+        ver = py_version._version  # pylint: disable = protected-access
         major, minor, patch = [ver.release[i] if len(ver.release) > i
                                else None for i in range(3)]
         pre_release: t.Optional[t.Sequence[
             t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]]] = None
         local = None
-        pre_ver: t.Optional[t.Tuple[None, int]]
+        pre_ver: t.Optional[t.Tuple[str | None, int]]
         if len(ver.release) == 4:
             pre_ver = (None, ver.release[3])
         elif len(ver.release) > 4:
@@ -176,12 +105,14 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
             local = tuple(itertools.chain.from_iterable(
                 (dot, str(_)) for dot, _ in zip('.' * len(ver.local), ver.local)))[1:]
         _LOG.debug('parsing %s %s', type(py_version), py_version)
+        assert major is not None
         return cls(major, minor, patch, pre_release=pre_release, local=local)
 
     @classmethod
     def from_sem_version(cls, sem_version: t.Union[dict, semver.VersionInfo]):
         """Create version from semantic version object."""
         _LOG.debug('parsing %s %s', type(sem_version), sem_version)
+        local: str | tuple | None
         if isinstance(sem_version, semver.VersionInfo):
             major, minor, patch = sem_version.major, sem_version.minor, sem_version.patch
             pre_release = sem_version.prerelease
@@ -193,24 +124,24 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
         if pre_release is not None:
             raise NotImplementedError(sem_version)
         if local is not None:
-            local = cls._parse_local_str(f'+{local}')
+            local = parse_local_str(f'+{local}')
         return cls(major, minor, patch, pre_release=pre_release, local=local)
 
     @classmethod
     def from_version(cls, version: 'Version'):
         return cls.from_dict(version.to_dict())
 
-    def __init__(
+    def __init__(  # pylint: disable = keyword-arg-before-vararg, too-many-arguments
             self, major: int, minor: t.Optional[int] = None, patch: t.Optional[int] = None, *args,
-            pre_release: t.Sequence[
-                t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]] = None,
-            local: t.Union[str, tuple] = None):
+            pre_release: t.Optional[t.Sequence[
+                t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]]] = None,
+            local: t.Union[str, tuple, None] = None):
         self._major: t.Optional[int] = None
         self._minor: t.Optional[int] = None
         self._patch: t.Optional[int] = None
         self._pre_release: t.Optional[
             t.List[t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]]] = None
-        self._local: t.Optional[t.Sequence[str]] = None
+        self._local: t.Optional[t.Tuple[str, ...]] = None
 
         self.release = major, minor, patch
 
@@ -224,7 +155,7 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
                 args = args[consumed_args:]
             else:
                 pre_release = None
-        self.pre_release = pre_release
+        self.pre_release = pre_release if pre_release is None else list(pre_release)
 
         if args and local is not None:
             raise ValueError(f'args={args} and local={local} are present at the same time'
@@ -243,35 +174,51 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
 
     def _get_pre_release_from_args(self, args) -> t.Tuple[
             t.Sequence[t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]], int]:
+        """Get pre-release version component from args."""
+        if args and isinstance(args[0], tuple):
+            return self._get_prerelease_from_tuples(args)
+
         pre_release: t.List[t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]] = []
         consumed_args = 0
-        if args and isinstance(args[0], tuple):
-            for i, arg in enumerate(args):
-                if not isinstance(arg, tuple):
-                    break
-                if len(arg) == 3 and arg[0] in (None, '.', '-'):
-                    pre_release.append(arg)
-                    consumed_args += 1
-                    continue
-                if i == len(args) - 1:
+        accumulated: t.List[t.Union[int, str, None]] = []
+        for i, arg in enumerate(args):
+            if not accumulated:
+                if arg in (None, '.', '-'):
+                    if len(args) < i + 3:
+                        raise ValueError(
+                            'expected 3 consecutive values'
+                            f' from index {i} in args={args} in {repr(self)}')
+                else:
                     break
-                raise ValueError(f'pre-release segment arg={arg} (index {i} in args={args}'
-                                 f' in {repr(self)}) must be a 3-tuple')
-        else:
-            accumulated: t.List[t.Union[int, str]] = []
-            for i, arg in enumerate(args):
-                if not accumulated:
-                    if arg in (None, '.', '-'):
-                        if len(args) < i + 3:
-                            raise ValueError(f'expected 3 consecutive values from index {i}'
-                                             f' in args={args} in {repr(self)}')
-                    else:
-                        break
-                accumulated.append(arg)
+            accumulated.append(arg)
+            consumed_args += 1
+            if len(accumulated) == 3:
+                _separator, _type, _patch = \
+                    accumulated  # pylint: disable = unbalanced-tuple-unpacking
+                assert _separator is None or isinstance(_separator, str), _separator
+                assert _type is None or isinstance(_type, str), _type
+                assert _patch is None or isinstance(_patch, int), _patch
+                pre_release.append((_separator, _type, _patch))
+                accumulated = []
+        return pre_release, consumed_args
+
+    def _get_prerelease_from_tuples(self, args) -> t.Tuple[
+            t.Sequence[t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]], int]:
+        """Get pre-release version component from args, assuming they are sequence of tuples."""
+        pre_release: t.List[t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]] = []
+        consumed_args = 0
+        for i, arg in enumerate(args):
+            if not isinstance(arg, tuple):
+                break
+            if len(arg) == 3 and arg[0] in (None, '.', '-'):
+                pre_release.append(arg)
                 consumed_args += 1
-                if len(accumulated) == 3:
-                    pre_release.append(tuple(accumulated))
-                    accumulated = []
+                continue
+            if i == len(args) - 1:
+                break
+            raise ValueError(
+                f'pre-release segment arg={arg} (index {i} in args={args} in {repr(self)})'
+                ' must be a 3-tuple')
         return pre_release, consumed_args
 
     @property
@@ -312,7 +259,7 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
 
     @property
     def pre_release(self) -> t.Optional[
-            t.Sequence[t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]]]:
+            t.List[t.Tuple[t.Optional[str], t.Optional[str], t.Optional[int]]]]:
         """Pre-release version component."""
         if self._pre_release is None:
             return None
@@ -354,7 +301,7 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
         if pre_type is not None and not isinstance(pre_type, str):
             raise TypeError(
                 f'pre_type={repr(pre_type)} is of wrong type {type(pre_type)} in {repr(self)}')
-        if pre_type is not None and type(self)._pattern_letters.fullmatch(pre_type) is None:
+        if pre_type is not None and patterns.LETTERS.fullmatch(pre_type) is None:
             raise ValueError(f'pre_type={repr(pre_type)} has wrong value in {repr(self)}')
         if pre_patch is not None and not isinstance(pre_patch, int):
             raise TypeError(
@@ -393,7 +340,7 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
                 raise TypeError(f'local_part or local_separator {repr(part)} is of wrong type'
                                 f' {type(part)} in {repr(self)}')
             if i % 2 == 0:
-                if type(self)._pattern_alphanumeric.fullmatch(part) is None:
+                if patterns.ALPHANUMERIC.fullmatch(part) is None:
                     raise ValueError(f'local_part={repr(part)} has wrong value in {repr(self)}')
             elif part not in ('-', '.'):
                 raise ValueError(f'local_separator={repr(part)} has wrong value in {repr(self)}')
@@ -501,13 +448,13 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
         assert self._pre_release is not None
         version_tuple = self._pre_release[segment]
         if _version_tuple_checker(version_tuple, (True, True, False)):
-            return '{}{}'.format(*version_tuple[:2])
+            return '{}{}'.format(*version_tuple[:2])  # pylint: disable = consider-using-f-string
         if _version_tuple_checker(version_tuple, (True, False, True)):
             return f'{version_tuple[0]}{version_tuple[2]}'
         if _version_tuple_checker(version_tuple, (False, True, True)):
-            return '{}{}'.format(*version_tuple[1:])
+            return '{}{}'.format(*version_tuple[1:])  # pylint: disable = consider-using-f-string
         if _version_tuple_checker(version_tuple, (True, True, True)):
-            return '{}{}{}'.format(*version_tuple)
+            return '{}{}{}'.format(*version_tuple)  # pylint: disable = consider-using-f-string
         raise ValueError(f'cannot generate valid version string from {repr(self)}')
 
     def pre_release_to_str(self) -> str:

{version_query-1.6.1 → version_query-1.6.2/version_query.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: version-query
-Version: 1.6.1
+Version: 1.6.2
 Summary: Zero-overhead package versioning for Python.
 Home-page: https://github.com/mbdevpl/version-query
 Download-URL: 
@@ -81,7 +81,7 @@ Zero-overhead package versioning for Python.
     :alt: grade from Codacy
 
 .. image:: https://img.shields.io/github/license/mbdevpl/version-query.svg
-    :target: https://github.com/mbdevpl/version-query/blob/v1.6.1/NOTICE
+    :target: https://github.com/mbdevpl/version-query/blob/v1.6.2/NOTICE
     :alt: license
 
 Package versioning toolkit for Python which relies on git tags, git history traversal
@@ -361,9 +361,9 @@ Incrementing any version component clears all existing following components.
 Examples of how version is incremented:
 
 *   for ``1.5``, incrementing ``<major>`` results in ``2.0``;
-*   for ``1.5.1-2.4``, ``<minor>``++ results in ``1.6``;
-*   ``1.5.1-2.4``, ``<patch>``++, ``1.5.2``;
-*   ``1.5.1``, ``<major>``+=3, ``4.0.0``.
+*   for ``1.5.1-2.4``, ``<minor>`` ++ results in ``1.6``;
+*   ``1.5.1-2.4``, ``<patch>`` ++, ``1.5.2``;
+*   ``1.5.1``, ``<major>`` += 3, ``4.0.0``.
 
 
 API details
@@ -491,8 +491,8 @@ Requirements
 
 Python version 3.9 or later.
 
-Python libraries as specified in `requirements.txt <https://github.com/mbdevpl/version-query/blob/v1.6.1/requirements.txt>`_.
+Python libraries as specified in `requirements.txt <https://github.com/mbdevpl/version-query/blob/v1.6.2/requirements.txt>`_.
 
-Building and running tests additionally requires packages listed in `requirements_test.txt <https://github.com/mbdevpl/version-query/blob/v1.6.1/requirements_test.txt>`_.
+Building and running tests additionally requires packages listed in `requirements_test.txt <https://github.com/mbdevpl/version-query/blob/v1.6.2/requirements_test.txt>`_.
 
 Tested on Linux, macOS and Windows.

{version_query-1.6.1 → version_query-1.6.2}/version_query.egg-info/SOURCES.txt

@@ -17,6 +17,8 @@ setup.py
 ./version_query/_version.py
 ./version_query/git_query.py
 ./version_query/main.py
+./version_query/parser.py
+./version_query/patterns.py
 ./version_query/py.typed
 ./version_query/py_query.py
 ./version_query/query.py
@@ -32,6 +34,8 @@ version_query/__main__.py
 version_query/_version.py
 version_query/git_query.py
 version_query/main.py
+version_query/parser.py
+version_query/patterns.py
 version_query/py.typed
 version_query/py_query.py
 version_query/query.py