refactor: move some of code from version.py to dedicated files

Author: mbdevpl

version_query/parser.py

@@ -0,0 +1,54 @@
+"""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/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/version.py

@@ -4,12 +4,14 @@
 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'}
@@ -18,6 +20,7 @@
 @enum.unique
 class VersionComponent(enum.IntEnum):
     """Enumeration of standard version components."""
+
     # pylint: disable = invalid-name
 
     Major = 1 << 1
@@ -39,87 +42,10 @@ class Version(collections.abc.Hashable):  # pylint: disable = too-many-public-me
     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)
-
     @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',
@@ -129,9 +55,9 @@ def from_str(cls, version_str: str):
         _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)
 
@@ -196,7 +122,7 @@ def from_sem_version(cls, sem_version: t.Union[dict, semver.VersionInfo]):
         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
@@ -357,7 +283,7 @@ def _check_pre_release_parts(self, pre_separator, pre_type, pre_patch):
         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(
@@ -396,7 +322,7 @@ def local(self, local: t.Optional[t.Sequence[str]]):
                 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)}')