plexus-python-pulse-common 1.1.87__tar.gz → 1.1.88__tar.gz

{plexus_python_pulse_common-1.1.87 → plexus_python_pulse_common-1.1.88}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-pulse-common
-Version: 1.1.87
+Version: 1.1.88
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{plexus_python_pulse_common-1.1.87 → plexus_python_pulse_common-1.1.88}/src/plexus/pulse/common/utils/ormutils.py

@@ -551,7 +551,10 @@ def model_revision_type(dialect: str | None = None) -> sa.types.TypeEngine[int]:
     raise ValueError(f"unsupported database dialect '{dialect}'")
 
 
-def index_condition_kwarg(dialect: str | None = None, clause: sa.TextClause | None = None) -> dict[str, sa.TextClause]:
+def index_condition_kwarg(
+    dialect: str | None = None,
+    clause: sa.ClauseElement | None = None
+) -> dict[str, sa.ClauseElement | None]:
     if dialect is None:
         dialect = dialects.postgresql
     if dialect == dialects.postgresql:
@@ -728,7 +731,7 @@ def make_snapshot_model_mixin(dialect: str | None = None) -> type[SnapshotModelM
                 index_name,
                 "record_sqn",
                 unique=True,
-                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
+                **index_condition_kwarg(dialect, sa.column("expired_at").is_(None)),
             )
 
         @classmethod
@@ -736,7 +739,7 @@ def make_snapshot_model_mixin(dialect: str | None = None) -> type[SnapshotModelM
             return sa.Index(
                 index_name,
                 *fields,
-                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
+                **index_condition_kwarg(dialect, sa.column("expired_at").is_(None)),
             )
 
         @classmethod
@@ -745,7 +748,7 @@ def make_snapshot_model_mixin(dialect: str | None = None) -> type[SnapshotModelM
                 index_name,
                 *fields,
                 unique=True,
-                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
+                **index_condition_kwarg(dialect, sa.column("expired_at").is_(None)),
             )
 
     return ModelMixin
@@ -865,7 +868,7 @@ def make_revision_model_mixin(dialect: str | None = None) -> type[RevisionModelM
                 index_name,
                 "record_sqn",
                 unique=True,
-                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
+                **index_condition_kwarg(dialect, sa.column("expired_at").is_(None)),
             )
 
         @classmethod
@@ -873,7 +876,7 @@ def make_revision_model_mixin(dialect: str | None = None) -> type[RevisionModelM
             return sa.Index(
                 index_name,
                 *fields,
-                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
+                **index_condition_kwarg(dialect, sa.column("expired_at").is_(None)),
             )
 
         @classmethod
@@ -882,7 +885,7 @@ def make_revision_model_mixin(dialect: str | None = None) -> type[RevisionModelM
                 index_name,
                 *fields,
                 unique=True,
-                **index_condition_kwarg(dialect, sa.text('"expired_at" IS NULL')),
+                **index_condition_kwarg(dialect, sa.column("expired_at").is_(None)),
             )
 
     return ModelMixin

{plexus_python_pulse_common-1.1.87 → plexus_python_pulse_common-1.1.88}/src/plexus/pulse/common/utils/strutils.py

@@ -28,6 +28,8 @@ __all__ = [
     "strict_fragmented_abspath_parser",
     "email_address_pattern",
     "email_address_parser",
+    "numeric_version_pattern",
+    "numeric_version_parser",
     "semver_pattern",
     "semver_parser",
     "colon_tag_pattern",
@@ -91,6 +93,7 @@ sharp_token: pp.ParserElement = pp.Char("#")
 lower_regexp: re.Pattern[str] = re.compile(r"[a-z]")
 upper_regexp: re.Pattern[str] = re.compile(r"[A-Z]")
 digit_regexp: re.Pattern[str] = re.compile(r"[0-9]")
+alpha_regexp: re.Pattern[str] = re.compile(r"[a-zA-Z]")
 lower_digit_regexp: re.Pattern[str] = re.compile(r"[a-z0-9]")
 upper_digit_regexp: re.Pattern[str] = re.compile(r"[A-Z0-9]")
 alpha_digit_regexp: re.Pattern[str] = re.compile(r"[a-zA-Z0-9]")
@@ -99,6 +102,7 @@ hex_digit_regexp: re.Pattern[str] = re.compile(r"[a-f0-9]")
 lowers_regexp: re.Pattern[str] = re.compile(rf"{lower_regexp.pattern}+")
 uppers_regexp: re.Pattern[str] = re.compile(rf"{upper_regexp.pattern}+")
 digits_regexp: re.Pattern[str] = re.compile(rf"{digit_regexp.pattern}+")
+alphas_regexp: re.Pattern[str] = re.compile(rf"{alpha_regexp.pattern}+")
 lower_digits_regexp: re.Pattern[str] = re.compile(rf"{lower_digit_regexp.pattern}+")
 upper_digits_regexp: re.Pattern[str] = re.compile(rf"{upper_digit_regexp.pattern}+")
 alpha_digits_regexp: re.Pattern[str] = re.compile(rf"{alpha_digit_regexp.pattern}+")
@@ -110,6 +114,7 @@ strict_chars_regexp: re.Pattern[str] = re.compile(rf"({alpha_digit_regexp.patter
 lower_element: pp.ParserElement = pp.Regex(lower_regexp.pattern)
 upper_element: pp.ParserElement = pp.Regex(upper_regexp.pattern)
 digit_element: pp.ParserElement = pp.Regex(digit_regexp.pattern)
+alpha_element: pp.ParserElement = pp.Regex(alpha_regexp.pattern)
 lower_digit_element: pp.ParserElement = pp.Regex(lower_digit_regexp.pattern)
 upper_digit_element: pp.ParserElement = pp.Regex(upper_digit_regexp.pattern)
 alpha_digit_element: pp.ParserElement = pp.Regex(alpha_digit_regexp.pattern)
@@ -118,6 +123,7 @@ hex_digit_element: pp.ParserElement = pp.Regex(hex_digit_regexp.pattern)
 lowers_element: pp.ParserElement = pp.Regex(lowers_regexp.pattern)
 uppers_element: pp.ParserElement = pp.Regex(uppers_regexp.pattern)
 digits_element: pp.ParserElement = pp.Regex(digits_regexp.pattern)
+alphas_element: pp.ParserElement = pp.Regex(alphas_regexp.pattern)
 lower_digits_element: pp.ParserElement = pp.Regex(lower_digits_regexp.pattern)
 upper_digits_element: pp.ParserElement = pp.Regex(upper_digits_regexp.pattern)
 alpha_digits_element: pp.ParserElement = pp.Regex(alpha_digits_regexp.pattern)
@@ -184,10 +190,14 @@ email_address_regexp: re.Pattern[str] = re.compile(
     rf"(({lower_digit_regexp.pattern}|[_-])+)(?:\.({lower_digit_regexp.pattern}|[_-])+)*@(?:{kebab_case_regexp.pattern}\.)+({lower_digit_regexp.pattern}{{2,63}})")
 email_address_element: pp.ParserElement = pp.Regex(email_address_regexp.pattern)
 
+numeric_version_regexp: re.Pattern[str] = re.compile(
+    rf"(?:{number_regexp.pattern})(?:\.(?:{number_regexp.pattern}))*")
+numeric_version_element: pp.ParserElement = pp.Regex(numeric_version_regexp.pattern)
+
 semver_regexp: re.Pattern[str] = re.compile(
-    rf"({number_regexp.pattern})\.({number_regexp.pattern})\.({number_regexp.pattern})"
-    rf"(?:-{alpha_digits_regexp.pattern}(?:\.{alpha_digits_regexp.pattern})*)?"
-    rf"(?:\+{alpha_digits_regexp.pattern}(?:\.{alpha_digits_regexp.pattern})*)?")
+    rf"(?:{number_regexp.pattern})\.(?:{number_regexp.pattern})\.(?:{number_regexp.pattern})"
+    rf"(?:-(?:(?:{alpha_digit_regexp.pattern}|-)*(?:{alpha_regexp.pattern}|-)(?:{alpha_digit_regexp.pattern}|-)*|{number_regexp.pattern})(?:\.(?:(?:{alpha_digit_regexp.pattern}|-)*(?:{alpha_regexp.pattern}|-)(?:{alpha_digit_regexp.pattern}|-)*|{number_regexp.pattern}))*)?"
+    rf"(?:\+(?:{alpha_digit_regexp.pattern}|-)+(?:\.(?:{alpha_digit_regexp.pattern}|-)+)*)?")
 semver_element: pp.ParserElement = pp.Regex(semver_regexp.pattern)
 
 colon_tag_regexp: re.Pattern[str] = re.compile(rf"{snake_case_regexp.pattern}(?::{snake_case_regexp.pattern})*")
@@ -229,6 +239,9 @@ strict_fragmented_abspath_parser = make_string_parser(strict_fragmented_abspath_
 email_address_pattern = make_string_pattern(email_address_regexp)
 email_address_parser = make_string_parser(email_address_element)
 
+numeric_version_pattern = make_string_pattern(numeric_version_regexp)
+numeric_version_parser = make_string_parser(numeric_version_element)
+
 semver_pattern = make_string_pattern(semver_regexp)
 semver_parser = make_string_parser(semver_element)
 

{plexus_python_pulse_common-1.1.87 → plexus_python_pulse_common-1.1.88}/src/plexus_python_pulse_common.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexus-python-pulse-common
-Version: 1.1.87
+Version: 1.1.88
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13

{plexus_python_pulse_common-1.1.87 → plexus_python_pulse_common-1.1.88}/test/plexus_tests/pulse/common/utils/strutils_test.py

@@ -10,6 +10,7 @@ from plexus.pulse.common.utils.strutils import dot_case_parser, dot_case_pattern
 from plexus.pulse.common.utils.strutils import email_address_parser, email_address_pattern
 from plexus.pulse.common.utils.strutils import hex_string_parser, hex_string_pattern
 from plexus.pulse.common.utils.strutils import kebab_case_parser, kebab_case_pattern
+from plexus.pulse.common.utils.strutils import numeric_version_parser, numeric_version_pattern
 from plexus.pulse.common.utils.strutils import parse_bag_name, parse_user_email, parse_user_name, parse_vehicle_name
 from plexus.pulse.common.utils.strutils import semver_parser, semver_pattern
 from plexus.pulse.common.utils.strutils import snake_case_parser, snake_case_pattern
@@ -32,8 +33,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_hex_string_pattern)
     @ddt.unpack
     def test_hex_string_pattern(self, data):
-        self.assertIsNotNone(hex_string_pattern.match(data))
-        self.assertIsNotNone(hex_string_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(hex_string_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(hex_string_parser.parse_string(data, parse_all=True))
 
     data_hex_string_pattern__bad_cases = [
         ("",),
@@ -48,9 +51,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_hex_string_pattern__bad_cases)
     @ddt.unpack
     def test_hex_string_pattern__bad_cases(self, data):
-        self.assertIsNone(hex_string_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            hex_string_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(hex_string_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                hex_string_parser.parse_string(data, parse_all=True)
 
     data_snake_case_pattern = [
         ("d",),
@@ -75,8 +80,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_snake_case_pattern)
     @ddt.unpack
     def test_snake_case_pattern(self, data):
-        self.assertIsNotNone(snake_case_pattern.match(data))
-        self.assertIsNotNone(snake_case_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(snake_case_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(snake_case_parser.parse_string(data, parse_all=True))
 
     data_snake_case_pattern__bad_cases = [
         ("",),
@@ -102,9 +109,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_snake_case_pattern__bad_cases)
     @ddt.unpack
     def test_snake_case_pattern__bad_cases(self, data):
-        self.assertIsNone(snake_case_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            snake_case_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(snake_case_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                snake_case_parser.parse_string(data, parse_all=True)
 
     data_kebab_case_pattern = [
         ("d",),
@@ -129,8 +138,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_kebab_case_pattern)
     @ddt.unpack
     def test_kebab_case_pattern(self, data):
-        self.assertIsNotNone(kebab_case_pattern.match(data))
-        self.assertIsNotNone(kebab_case_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(kebab_case_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(kebab_case_parser.parse_string(data, parse_all=True))
 
     data_kebab_case_pattern__bad_cases = [
         ("",),
@@ -156,9 +167,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_kebab_case_pattern__bad_cases)
     @ddt.unpack
     def test_kebab_case_pattern__bad_cases(self, data):
-        self.assertIsNone(kebab_case_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            kebab_case_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(kebab_case_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                kebab_case_parser.parse_string(data, parse_all=True)
 
     data_dot_case_pattern = [
         ("d",),
@@ -183,8 +196,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_dot_case_pattern)
     @ddt.unpack
     def test_dot_case_pattern(self, data):
-        self.assertIsNotNone(dot_case_pattern.match(data))
-        self.assertIsNotNone(dot_case_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(dot_case_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(dot_case_parser.parse_string(data, parse_all=True))
 
     data_dot_case_pattern__bad_cases = [
         ("",),
@@ -210,9 +225,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_dot_case_pattern__bad_cases)
     @ddt.unpack
     def test_dot_case_pattern__bad_cases(self, data):
-        self.assertIsNone(dot_case_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            dot_case_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(dot_case_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                dot_case_parser.parse_string(data, parse_all=True)
 
     data_strict_relpath_pattern = [
         ("",),
@@ -239,8 +256,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_strict_relpath_pattern)
     @ddt.unpack
     def test_strict_relpath_pattern(self, data):
-        self.assertIsNotNone(strict_relpath_pattern.match(data))
-        self.assertIsNotNone(strict_relpath_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(strict_relpath_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(strict_relpath_parser.parse_string(data, parse_all=True))
 
     data_strict_relpath_pattern__bad_cases = [
         ("/",),
@@ -293,9 +312,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_strict_relpath_pattern__bad_cases)
     @ddt.unpack
     def test_strict_relpath_pattern__bad_cases(self, data):
-        self.assertIsNone(strict_relpath_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            strict_relpath_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(strict_relpath_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                strict_relpath_parser.parse_string(data, parse_all=True)
 
     data_strict_abspath_pattern = [
         ("/",),
@@ -322,8 +343,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_strict_abspath_pattern)
     @ddt.unpack
     def test_strict_abspath_pattern(self, data):
-        self.assertIsNotNone(strict_abspath_pattern.match(data))
-        self.assertIsNotNone(strict_abspath_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(strict_abspath_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(strict_abspath_parser.parse_string(data, parse_all=True))
 
     data_strict_abspath_pattern__bad_cases = [
         ("",),
@@ -376,9 +399,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_strict_abspath_pattern__bad_cases)
     @ddt.unpack
     def test_strict_abspath_pattern__bad_cases(self, data):
-        self.assertIsNone(strict_abspath_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            strict_abspath_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(strict_abspath_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                strict_abspath_parser.parse_string(data, parse_all=True)
 
     data_strict_fragmented_relpath_pattern = [
         ("archive.zip",),
@@ -403,8 +428,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_strict_fragmented_relpath_pattern)
     @ddt.unpack
     def test_strict_fragmented_relpath_pattern(self, data):
-        self.assertIsNotNone(strict_fragmented_relpath_pattern.match(data))
-        self.assertIsNotNone(strict_fragmented_relpath_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(strict_fragmented_relpath_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(strict_fragmented_relpath_parser.parse_string(data, parse_all=True))
 
     data_strict_fragmented_relpath_pattern__bad_cases = [
         ("/archive.zip",),
@@ -450,9 +477,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_strict_fragmented_relpath_pattern__bad_cases)
     @ddt.unpack
     def test_strict_fragmented_relpath_pattern__bad_cases(self, data):
-        self.assertIsNone(strict_fragmented_relpath_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            strict_fragmented_relpath_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(strict_fragmented_relpath_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                strict_fragmented_relpath_parser.parse_string(data, parse_all=True)
 
     data_strict_fragmented_abspath_pattern = [
         ("/archive.zip",),
@@ -477,8 +506,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_strict_fragmented_abspath_pattern)
     @ddt.unpack
     def test_strict_fragmented_abspath_pattern(self, data):
-        self.assertIsNotNone(strict_fragmented_abspath_pattern.match(data))
-        self.assertIsNotNone(strict_fragmented_abspath_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(strict_fragmented_abspath_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(strict_fragmented_abspath_parser.parse_string(data, parse_all=True))
 
     data_strict_fragmented_abspath_pattern__bad_cases = [
         ("archive.zip",),
@@ -524,9 +555,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_strict_fragmented_abspath_pattern__bad_cases)
     @ddt.unpack
     def test_strict_fragmented_abspath_pattern__bad_cases(self, data):
-        self.assertIsNone(strict_fragmented_abspath_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            strict_fragmented_abspath_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(strict_fragmented_abspath_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                strict_fragmented_abspath_parser.parse_string(data, parse_all=True)
 
     data_email_address_pattern = [
         ("someone@dummy.com",),
@@ -543,8 +576,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_email_address_pattern)
     @ddt.unpack
     def test_email_address_pattern(self, data):
-        self.assertIsNotNone(email_address_pattern.match(data))
-        self.assertIsNotNone(email_address_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(email_address_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(email_address_parser.parse_string(data, parse_all=True))
 
     data_email_address_pattern__bad_cases = [
         ("",),
@@ -561,9 +596,48 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_email_address_pattern__bad_cases)
     @ddt.unpack
     def test_email_address_pattern__bad_cases(self, data):
-        self.assertIsNone(email_address_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            email_address_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(email_address_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                email_address_parser.parse_string(data, parse_all=True)
+
+    data_numeric_version_pattern = [
+        ("0",),
+        ("1",),
+        ("1.1",),
+        ("1.1.1",),
+        ("1.1.1.1",),
+        ("10.20.30.40.50",),
+    ]
+
+    @ddt.idata(data_numeric_version_pattern)
+    @ddt.unpack
+    def test_numeric_version_pattern(self, data):
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(numeric_version_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(numeric_version_parser.parse_string(data, parse_all=True))
+
+    data_numeric_version_pattern__bad_cases = [
+        ("",),
+        ("01",),
+        ("1.01",),
+        ("1.",),
+        (".1",),
+        ("1..2",),
+        ("1.2-alpha",),
+        ("1.2+build",),
+    ]
+
+    @ddt.idata(data_numeric_version_pattern__bad_cases)
+    @ddt.unpack
+    def test_numeric_version_pattern__bad_cases(self, data):
+        with self.subTest(checker="regex"):
+            self.assertIsNone(numeric_version_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                numeric_version_parser.parse_string(data, parse_all=True)
 
     data_semver_pattern = [
         ("0.0.0",),
@@ -574,13 +648,22 @@ class StrUtilsTest(unittest.TestCase):
         ("1.0.0-alpha+build.1",),
         ("1.0.0-0.3.7",),
         ("1.0.0-x.7.z.92",),
+        ("1.0.0-alpha+beta-",),
+        ("1.2.3-alpha-beta",),
+        ("1.2.3-1.alphas-after-digits.2",),
+        ("1.2.3-01-leading-zero-but-this-is-a-string",),
+        ("1.2.3+some-hash",),
+        ("1.2.3+build.01",),
+        ("1.2.3-x-y-z.--+anything-after-plus-is-ok",),
     ]
 
     @ddt.idata(data_semver_pattern)
     @ddt.unpack
     def test_semver_pattern(self, data):
-        self.assertIsNotNone(semver_pattern.match(data))
-        self.assertIsNotNone(semver_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(semver_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(semver_parser.parse_string(data, parse_all=True))
 
     data_semver_pattern__bad_cases = [
         ("",),
@@ -593,15 +676,22 @@ class StrUtilsTest(unittest.TestCase):
         ("1.0.0-",),
         ("1.0.0+",),
         ("1.0.0-alpha+",),
-        ("1.0.0-alpha+beta-",),
+        ("1.2.3-01",),
+        ("1.2.3-alpha.01",),
+        ("1.2.3-001a.01",),
+        ("1.2.3-alpha..1",),
+        ("1.2.3+build..1",),
+        ("1.2.3-alpha+some_hash",),
     ]
 
     @ddt.idata(data_semver_pattern__bad_cases)
     @ddt.unpack
     def test_semver_pattern__bad_cases(self, data):
-        self.assertIsNone(semver_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            semver_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(semver_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                semver_parser.parse_string(data, parse_all=True)
 
     data_colon_tag_pattern = [
         ("dummy",),
@@ -613,8 +703,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_colon_tag_pattern)
     @ddt.unpack
     def test_colon_tag_pattern(self, data):
-        self.assertIsNotNone(colon_tag_pattern.match(data))
-        self.assertIsNotNone(colon_tag_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(colon_tag_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(colon_tag_parser.parse_string(data, parse_all=True))
 
     data_colon_tag_pattern__bad_cases = [
         ("",),
@@ -630,9 +722,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_colon_tag_pattern__bad_cases)
     @ddt.unpack
     def test_colon_tag_pattern__bad_cases(self, data):
-        self.assertIsNone(colon_tag_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            colon_tag_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(colon_tag_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                colon_tag_parser.parse_string(data, parse_all=True)
 
     data_slash_tag_pattern = [
         ("dummy",),
@@ -644,8 +738,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_slash_tag_pattern)
     @ddt.unpack
     def test_slash_tag_pattern(self, data):
-        self.assertIsNotNone(slash_tag_pattern.match(data))
-        self.assertIsNotNone(slash_tag_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(slash_tag_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(slash_tag_parser.parse_string(data, parse_all=True))
 
     data_slash_tag_pattern__bad_cases = [
         ("",),
@@ -661,9 +757,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_slash_tag_pattern__bad_cases)
     @ddt.unpack
     def test_slash_tag_pattern__bad_cases(self, data):
-        self.assertIsNone(slash_tag_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            slash_tag_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(slash_tag_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                slash_tag_parser.parse_string(data, parse_all=True)
 
     data_topic_pattern = [
         ("/dummy_sensor",),
@@ -676,8 +774,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_topic_pattern)
     @ddt.unpack
     def test_topic_pattern(self, data):
-        self.assertIsNotNone(topic_pattern.match(data))
-        self.assertIsNotNone(topic_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(topic_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(topic_parser.parse_string(data, parse_all=True))
 
     data_topic_pattern__bad_cases = [
         ("",),
@@ -693,9 +793,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_topic_pattern__bad_cases)
     @ddt.unpack
     def test_topic_pattern__bad_cases(self, data):
-        self.assertIsNone(topic_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            topic_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(topic_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                topic_parser.parse_string(data, parse_all=True)
 
     data_vin_code_pattern = [
         ("00000000000000000",),
@@ -707,8 +809,10 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_vin_code_pattern)
     @ddt.unpack
     def test_vin_code_pattern(self, data):
-        self.assertIsNotNone(vin_code_pattern.match(data))
-        self.assertIsNotNone(vin_code_parser.parse_string(data, parse_all=True))
+        with self.subTest(checker="regex"):
+            self.assertIsNotNone(vin_code_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            self.assertIsNotNone(vin_code_parser.parse_string(data, parse_all=True))
 
     data_vin_code_pattern__bad_cases = [
         ("",),
@@ -723,9 +827,11 @@ class StrUtilsTest(unittest.TestCase):
     @ddt.idata(data_vin_code_pattern__bad_cases)
     @ddt.unpack
     def test_vin_code_pattern__bad_cases(self, data):
-        self.assertIsNone(vin_code_pattern.match(data))
-        with self.assertRaises(pp.ParseException):
-            vin_code_parser.parse_string(data, parse_all=True)
+        with self.subTest(checker="regex"):
+            self.assertIsNone(vin_code_pattern.fullmatch(data))
+        with self.subTest(checker="parser"):
+            with self.assertRaises(pp.ParseException):
+                vin_code_parser.parse_string(data, parse_all=True)
 
     data_parse_user_name = [
         ("dummy.person", UserName("dummy", "person", 0)),