perf: simply Specifier regex (#1106)

Examining the specifier regex, two potential optimizations seem
worthwhile:

1. Negative lookbehinds can be eliminated if we combine the operator
   regex with the version regex -- this avoids crawling the same
   characters of a string forwards and backwards.

2. Do more string operations, like `strip()` rather than having the
   regex engine do this work.

These ideas are somewhat combined, in that getting rid of the lookbehinds
only really works by eliminating the group selectors in use. And removing
the group selectors in the regex requires that we do more string
operations.

This also interestingly results in a regex stored in the `Specifier`
which matches its secondary usage in `_tokenizer`, which was previously
very slightly misaligned (in that the group captures in the regex were
unused).

Author: sirosen

src/packaging/_tokenizer.py

@@ -75,7 +75,7 @@ def __str__(self) -> str:
         re.VERBOSE,
     ),
     "SPECIFIER": re.compile(
-        Specifier._operator_regex_str + Specifier._version_regex_str,
+        Specifier._specifier_regex_str,
         re.VERBOSE | re.IGNORECASE,
     ),
     "AT": re.compile(r"\@"),

src/packaging/specifiers.py

@@ -169,18 +169,15 @@ class Specifier(BaseSpecifier):
 
     __slots__ = ("_prereleases", "_spec", "_spec_version", "_wildcard_split")
 
-    _operator_regex_str = r"""
-        (?P<operator>(~=|==|!=|<=|>=|<|>|===))
-        """
-    _version_regex_str = r"""
-        (?P<version>
+    _specifier_regex_str = r"""
+        (?:
             (?:
                 # The identity operators allow for an escape hatch that will
                 # do an exact string match of the version you wish to install.
                 # This will not be parsed by PEP 440 and we cannot determine
                 # any semantic meaning from it. This operator is discouraged
                 # but included entirely as an escape hatch.
-                (?<====)  # Only match for the identity operator
+                ===  # Only match for the identity operator
                 \s*
                 [^\s;)]*  # The arbitrary version can be just about anything,
                           # we match everything except for whitespace, a
@@ -192,7 +189,7 @@ class Specifier(BaseSpecifier):
                 # The (non)equality operators allow for wild card and local
                 # versions to be specified so we have to define these two
                 # operators separately to enable that.
-                (?<===|!=)            # Only match for equals and not equals
+                (?:==|!=)            # Only match for equals and not equals
 
                 \s*
                 v?
@@ -221,7 +218,7 @@ class Specifier(BaseSpecifier):
             (?:
                 # The compatible operator requires at least two digits in the
                 # release segment.
-                (?<=~=)               # Only match for the compatible operator
+                (?:~=)               # Only match for the compatible operator
 
                 \s*
                 v?
@@ -244,9 +241,7 @@ class Specifier(BaseSpecifier):
                 # (non)equality operators do. Specifically they do not allow
                 # local versions to be specified nor do they allow the prefix
                 # matching wild cards.
-                (?<!==|!=|~=)         # We have special cases for these
-                                      # operators so we want to make sure they
-                                      # don't match here.
+                (?:<=|>=|<|>)
 
                 \s*
                 v?
@@ -267,8 +262,7 @@ class Specifier(BaseSpecifier):
         """
 
     _regex = re.compile(
-        r"\s*" + _operator_regex_str + _version_regex_str + r"\s*",
-        re.VERBOSE | re.IGNORECASE,
+        r"\s*" + _specifier_regex_str + r"\s*", re.VERBOSE | re.IGNORECASE
     )
 
     _operators: Final = {
@@ -295,14 +289,18 @@ def __init__(self, spec: str = "", prereleases: bool | None = None) -> None:
         :raises InvalidSpecifier:
             If the given specifier is invalid (i.e. bad syntax).
         """
-        match = self._regex.fullmatch(spec)
-        if not match:
+        if not self._regex.fullmatch(spec):
             raise InvalidSpecifier(f"Invalid specifier: {spec!r}")
 
-        self._spec: tuple[str, str] = (
-            match.group("operator").strip(),
-            match.group("version").strip(),
-        )
+        spec = spec.strip()
+        if spec.startswith("==="):
+            operator, version = spec[:3], spec[3:].strip()
+        elif spec.startswith(("~=", "==", "!=", "<=", ">=")):
+            operator, version = spec[:2], spec[2:].strip()
+        else:
+            operator, version = spec[:1], spec[1:].strip()
+
+        self._spec: tuple[str, str] = (operator, version)
 
         # Store whether or not this Specifier should accept prereleases
         self._prereleases = prereleases