[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

.venv/lib/python3.10/site-packages/setuptools/_distutils/versionpredicate.py

@@ -1,16 +1,21 @@
 """Module for parsing and testing package version predicate strings.
 """
-import re
-import distutils.version
+from __future__ import annotations
+
 import operator
+import re
+
+import distutils.version
 
 
-re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)",
-    re.ASCII)
+re_validPackage = re.compile(
+    r'(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)',
+    re.ASCII,
+)
 # (package) (rest)
 
-re_paren = re.compile(r"^\s*\((.*)\)\s*$") # (list) inside of parentheses
-re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$")
+re_paren = re.compile(r'^\s*\((.*)\)\s*$')  # (list) inside of parentheses
+re_splitComparison = re.compile(r'^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$')
 # (comp) (version)
 
 
@@ -21,12 +26,16 @@ def splitUp(pred):
     """
     res = re_splitComparison.match(pred)
     if not res:
-        raise ValueError("bad package restriction syntax: %r" % pred)
+        raise ValueError('bad package restriction syntax: %r' % pred)
     comp, verStr = res.groups()
     return (comp, distutils.version.StrictVersion(verStr))
 
-compmap = {"<": operator.lt, "<=": operator.le, "==": operator.eq,
-           ">": operator.gt, ">=": operator.ge, "!=": operator.ne}
+
+compmap = {
+    '<': operator.lt, '<=': operator.le, '==': operator.eq,
+    '>': operator.gt, '>=': operator.ge, '!=': operator.ne,
+}
+
 
 class VersionPredicate:
     """Parse and test package version predicates.
@@ -102,28 +111,30 @@ class VersionPredicate:
 
         versionPredicateStr = versionPredicateStr.strip()
         if not versionPredicateStr:
-            raise ValueError("empty package restriction")
+            raise ValueError('empty package restriction')
         match = re_validPackage.match(versionPredicateStr)
         if not match:
-            raise ValueError("bad package name in %r" % versionPredicateStr)
+            raise ValueError('bad package name in %r' % versionPredicateStr)
         self.name, paren = match.groups()
         paren = paren.strip()
         if paren:
             match = re_paren.match(paren)
             if not match:
-                raise ValueError("expected parenthesized list: %r" % paren)
+                raise ValueError('expected parenthesized list: %r' % paren)
             str = match.groups()[0]
-            self.pred = [splitUp(aPred) for aPred in str.split(",")]
+            self.pred = [splitUp(aPred) for aPred in str.split(',')]
             if not self.pred:
-                raise ValueError("empty parenthesized list in %r"
-                                 % versionPredicateStr)
+                raise ValueError(
+                    'empty parenthesized list in %r'
+                    % versionPredicateStr,
+                )
         else:
             self.pred = []
 
     def __str__(self):
         if self.pred:
-            seq = [cond + " " + str(ver) for cond, ver in self.pred]
-            return self.name + " (" + ", ".join(seq) + ")"
+            seq = [cond + ' ' + str(ver) for cond, ver in self.pred]
+            return self.name + ' (' + ', '.join(seq) + ')'
         else:
             return self.name
 
@@ -140,6 +151,7 @@ class VersionPredicate:
 
 _provision_rx = None
 
+
 def split_provision(value):
     """Return the name and optional version number of a provision.
 
@@ -154,12 +166,13 @@ def split_provision(value):
     global _provision_rx
     if _provision_rx is None:
         _provision_rx = re.compile(
-            r"([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$",
-            re.ASCII)
+            r'([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$',
+            re.ASCII,
+        )
     value = value.strip()
     m = _provision_rx.match(value)
     if not m:
-        raise ValueError("illegal provides specification: %r" % value)
+        raise ValueError('illegal provides specification: %r' % value)
     ver = m.group(2) or None
     if ver:
         ver = distutils.version.StrictVersion(ver)