Merge pull request #2494 from zas/avoid_using_match

match -> match_: match is a statement in Python 3.10+

installer/i18n/nshutil.py

@@ -135,11 +135,11 @@ def unescape_string(text):
 
 
 def parse_langstring(line):
-    match = RE_LANGSTRING_LINE.match(line)
-    if match:
+    match_ = RE_LANGSTRING_LINE.match(line)
+    if match_:
         return (
-            match.group('identifier'),
-            unescape_string(match.group('text'))
+            match_.group('identifier'),
+            unescape_string(match_.group('text'))
         )
     else:
         return None

picard/cluster.py

@@ -283,9 +283,9 @@ class Cluster(FileList):
         # multiple matches -- calculate similarities to each of them
         def candidates():
             for release in releases:
-                match = self.metadata.compare_to_release(release, CLUSTER_COMPARISON_WEIGHTS)
-                if match.similarity >= threshold:
-                    yield match
+                match_ = self.metadata.compare_to_release(release, CLUSTER_COMPARISON_WEIGHTS)
+                if match_.similarity >= threshold:
+                    yield match_
 
         no_match = SimMatchRelease(similarity=-1, release=None)
         best_match = find_best_match(candidates(), no_match)

picard/script/functions.py

@@ -252,14 +252,14 @@ def func_rreplace(parser, text, old, new):
 ))
 def func_rsearch(parser, text, pattern):
     try:
-        match = re.search(pattern, text)
+        match_ = re.search(pattern, text)
     except re.error:
         return ''
-    if match:
+    if match_:
         try:
-            return match.group(1)
+            return match_.group(1)
         except IndexError:
-            return match.group(0)
+            return match_.group(0)
     return ''
 
 
@@ -887,9 +887,9 @@ def _delete_prefix(parser, text, *prefixes):
         prefixes = ('A', 'The')
     text = text.strip()
     rx = '(' + r'\s+)|('.join(map(re.escape, prefixes)) + r'\s+)'
-    match = re.match(rx, text)
-    if match:
-        pref = match.group()
+    match_ = re.match(rx, text)
+    if match_:
+        pref = match_.group()
         return text[len(pref):], pref.strip()
     return text, ''
 

picard/ui/coverartbox.py

@@ -534,9 +534,9 @@ class CoverArtBox(QtWidgets.QGroupBox):
         # Try getting image out of HTML (e.g. for Google image search detail view)
         try:
             html = data.decode()
-            match = re.search(HTML_IMG_SRC_REGEX, html)
-            if match:
-                url = QtCore.QUrl(match.group(1))
+            match_ = re.search(HTML_IMG_SRC_REGEX, html)
+            if match_:
+                url = QtCore.QUrl(match_.group(1))
         except UnicodeDecodeError as e:
             log.warning("Unable to decode dropped data format: %s", e)
         else:

picard/ui/options/plugins.py

@@ -634,11 +634,11 @@ class PluginsOptionsPage(OptionsPage):
         re_author = re.compile(r"(?P<author>.*?)\s*<(?P<email>.*?@.*?)>")
         for author in authors.split(','):
             author = author.strip()
-            match = re_author.fullmatch(author)
-            if match:
+            match_ = re_author.fullmatch(author)
+            if match_:
                 author_str = '<a href="mailto:{email}">{author}</a>'.format(
-                    email=escape(match['email']),
-                    author=escape(match['author']),
+                    email=escape(match_['email']),
+                    author=escape(match_['author']),
                 )
                 formatted_authors.append(author_str)
             else:

picard/ui/tagsfromfilenames.py

@@ -77,11 +77,11 @@ class TagMatchExpression:
         return list(OrderedDict.fromkeys(self._group_map.values()))
 
     def match_file(self, filename):
-        match = self._format_re.search(filename.replace('\\', '/'))
-        if match:
+        match_ = self._format_re.search(filename.replace('\\', '/'))
+        if match_:
             result = {}
             for group, tag in self._group_map.items():
-                value = match.group(group).strip()
+                value = match_.group(group).strip()
                 if tag in self._numeric_tags:
                     value = value.lstrip("0")
                 if self.replace_underscores:

picard/util/__init__.py

@@ -497,9 +497,9 @@ def parse_amazon_url(url):
     It returns a dict with host and asin keys on success, None else
     """
     r = re.compile(r'^https?://(?:www.)?(?P<host>.*?)(?:\:[0-9]+)?/.*/(?P<asin>[0-9B][0-9A-Z]{9})(?:[^0-9A-Z]|$)')
-    match = r.match(url)
-    if match is not None:
-        return match.groupdict()
+    match_ = r.match(url)
+    if match_ is not None:
+        return match_.groupdict()
     return None
 
 
@@ -611,9 +611,9 @@ def tracknum_from_filename(base_filename):
     """
     filename, _ext = os.path.splitext(base_filename)
     for pattern in _tracknum_regexps:
-        match = pattern.search(filename)
-        if match:
-            n = int(match.group('number'))
+        match_ = pattern.search(filename)
+        if match_:
+            n = int(match_.group('number'))
             # Numbers above 1900 are often years, track numbers should be much
             # smaller even for extensive collections
             if n > 0 and n < 1900:

picard/util/tags.py

@@ -200,9 +200,9 @@ def parse_comment_tag(name):  # noqa: E302
     if len(split) > 1:
         desc = split[1]
 
-    match = RE_COMMENT_LANG.match(desc)
-    if match:
-        lang = match.group(1)
+    match_ = RE_COMMENT_LANG.match(desc)
+    if match_:
+        lang = match_.group(1)
         desc = desc[4:]
         return lang, desc
 

picard/version.py

@@ -56,9 +56,9 @@ class Version(namedtuple('VersionBase', 'major minor patch identifier revision')
 
     @classmethod
     def from_string(cls, version_str):
-        match = cls._version_re.search(version_str)
-        if match:
-            (major, minor, patch, identifier, revision) = match.groups()
+        match_ = cls._version_re.search(version_str)
+        if match_:
+            (major, minor, patch, identifier, revision) = match_.groups()
             major = int(major)
             if minor is None:
                 return Version(major)

test/test_metadata.py

@@ -567,9 +567,9 @@ class CommonTests:
             release = load_test_json('release.json')
             metadata = Metadata()
             release_to_metadata(release, metadata)
-            match = metadata.compare_to_release(release, CLUSTER_COMPARISON_WEIGHTS)
-            self.assertEqual(1.0, match.similarity)
-            self.assertEqual(release, match.release)
+            match_ = metadata.compare_to_release(release, CLUSTER_COMPARISON_WEIGHTS)
+            self.assertEqual(1.0, match_.similarity)
+            self.assertEqual(release, match_.release)
 
         def test_compare_to_release_with_score(self):
             release = load_test_json('release.json')
@@ -577,8 +577,8 @@ class CommonTests:
             release_to_metadata(release, metadata)
             for score, sim in ((42, 0.42), ('42', 0.42), ('foo', 1.0), (None, 1.0)):
                 release['score'] = score
-                match = metadata.compare_to_release(release, CLUSTER_COMPARISON_WEIGHTS)
-                self.assertEqual(sim, match.similarity)
+                match_ = metadata.compare_to_release(release, CLUSTER_COMPARISON_WEIGHTS)
+                self.assertEqual(sim, match_.similarity)
 
         def test_compare_to_release_parts_totaltracks(self):
             release = load_test_json('release_multidisc.json')
@@ -667,9 +667,9 @@ class CommonTests:
             track_json = load_test_json('track.json')
             track = Track(track_json['id'])
             track_to_metadata(track_json, track)
-            match = track.metadata.compare_to_track(track_json, FILE_COMPARISON_WEIGHTS)
-            self.assertEqual(1.0, match.similarity)
-            self.assertEqual(track_json, match.track)
+            match_ = track.metadata.compare_to_track(track_json, FILE_COMPARISON_WEIGHTS)
+            self.assertEqual(1.0, match_.similarity)
+            self.assertEqual(track_json, match_.track)
 
         def test_compare_to_track_with_score(self):
             track_json = load_test_json('track.json')
@@ -677,20 +677,20 @@ class CommonTests:
             track_to_metadata(track_json, track)
             for score, sim in ((42, 0.42), ('42', 0.42), ('foo', 1.0), (None, 1.0)):
                 track_json['score'] = score
-                match = track.metadata.compare_to_track(track_json, FILE_COMPARISON_WEIGHTS)
-                self.assertEqual(sim, match.similarity)
+                match_ = track.metadata.compare_to_track(track_json, FILE_COMPARISON_WEIGHTS)
+                self.assertEqual(sim, match_.similarity)
 
         def test_compare_to_track_is_video(self):
             recording = load_test_json('recording_video_null.json')
             m = Metadata()
-            match = m.compare_to_track(recording, {'isvideo': 1})
-            self.assertEqual(1.0, match.similarity)
+            match_ = m.compare_to_track(recording, {'isvideo': 1})
+            self.assertEqual(1.0, match_.similarity)
             m['~video'] = '1'
-            match = m.compare_to_track(recording, {'isvideo': 1})
-            self.assertEqual(0.0, match.similarity)
+            match_ = m.compare_to_track(recording, {'isvideo': 1})
+            self.assertEqual(0.0, match_.similarity)
             recording['video'] = True
-            match = m.compare_to_track(recording, {'isvideo': 1})
-            self.assertEqual(1.0, match.similarity)
+            match_ = m.compare_to_track(recording, {'isvideo': 1})
+            self.assertEqual(1.0, match_.similarity)
 
         def test_compare_to_track_full(self):
             recording = load_test_json('recording_video_null.json')
@@ -703,10 +703,10 @@ class CommonTests:
                 'albumartist': 'Tim Green',
                 'tracknumber': '4',
             })
-            match = m.compare_to_track(recording, FILE_COMPARISON_WEIGHTS)
-            self.assertGreaterEqual(match.similarity, 0.8)
-            self.assertEqual(recording, match.track)
-            self.assertEqual(recording['releases'][0], match.release)
+            match_ = m.compare_to_track(recording, FILE_COMPARISON_WEIGHTS)
+            self.assertGreaterEqual(match_.similarity, 0.8)
+            self.assertEqual(recording, match_.track)
+            self.assertEqual(recording['releases'][0], match_.release)
 
         def test_compare_to_track_without_releases(self):
             self.set_config_values({