dev: upgrade pre-commit and friends for Python 3.8+ (#29502)

.pre-commit-config.yaml

@@ -23,7 +23,7 @@ repos:
     - id: pyupgrade
       name: pyupgrade
       entry: pyupgrade
-      args: ['--py36-plus']
+      args: ['--py38-plus']
       language: system
       types: [python]
       # We can't change this mock to unittest.mock until Python 3.8,

docs-ui/stories/core/typography/typography.stories.mdx

@@ -140,7 +140,7 @@ When a link appears on its own and the user likely knows that it's a link given
   - Add a solid underline in <ColorChip value="gray200" />
 
 ```js label=Styled_Components
-/* Link color is flexible, choose 
+/* Link color is flexible, choose
 between Gray 500, 400, and 300. */
 styled('a')`
   color: ${p => p.theme.gray500};

pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [tool.black]
 # File filtering is taken care of in pre-commit.
 line-length=100
-target-version=['py36']
+target-version=['py38']
 
 [tool.isort]
 profile = "black"

requirements-pre-commit.txt

@@ -1,6 +1,6 @@
-pre-commit==2.14.0
-black==21.7b0
+pre-commit==2.15.0
+black==21.9b0
 sentry-flake8==2.0.0
-pyupgrade==2.23.3
+pyupgrade==2.29.0
 isort==5.9.3
 requirements-parser>=0.2.0

setup.cfg

@@ -1,9 +1,8 @@
 [flake8]
 # File filtering is taken care of in pre-commit.
 # E203 false positive, see https://github.com/PyCQA/pycodestyle/issues/373
-# W605 false positive until python3.8: https://github.com/PyCQA/pycodestyle/issues/755
 # B011 We don't use PYTHONOPTIMIZE.
-ignore = F999,E203,E501,E128,E124,E402,W503,W504,W605,E731,C901,B007,B009,B010,B011
+ignore = F999,E203,E501,E128,E124,E402,W503,W504,E731,C901,B007,B009,B010,B011
 
 # XXX: E501 is ignored, which disables line length checking.
 # Currently, the black formatter doesn't wrap long strings: https://github.com/psf/black/issues/182#issuecomment-385325274

tests/sentry/api/helpers/test_group_index.py

@@ -29,7 +29,7 @@ class ValidateSearchFilterPermissionsTest(TestCase):
     @patch("sentry.analytics.record")
     def test_negative(self, mock_record):
         query = "!has:user"
-        with self.feature({"organizations:advanced-search": False}), self.assertRaisesRegexp(
+        with self.feature({"organizations:advanced-search": False}), self.assertRaisesRegex(
             ValidationError, ".*negative search.*"
         ):
             self.run_test(query)
@@ -38,7 +38,7 @@ class ValidateSearchFilterPermissionsTest(TestCase):
         self.assert_analytics_recorded(mock_record)
 
         query = "!something:123"
-        with self.feature({"organizations:advanced-search": False}), self.assertRaisesRegexp(
+        with self.feature({"organizations:advanced-search": False}), self.assertRaisesRegex(
             ValidationError, ".*negative search.*"
         ):
             self.run_test(query)
@@ -49,7 +49,7 @@ class ValidateSearchFilterPermissionsTest(TestCase):
     @patch("sentry.analytics.record")
     def test_wildcard(self, mock_record):
         query = "abc:hello*"
-        with self.feature({"organizations:advanced-search": False}), self.assertRaisesRegexp(
+        with self.feature({"organizations:advanced-search": False}), self.assertRaisesRegex(
             ValidationError, ".*wildcard search.*"
         ):
             self.run_test(query)
@@ -58,7 +58,7 @@ class ValidateSearchFilterPermissionsTest(TestCase):
         self.assert_analytics_recorded(mock_record)
 
         query = "raw * search"
-        with self.feature({"organizations:advanced-search": False}), self.assertRaisesRegexp(
+        with self.feature({"organizations:advanced-search": False}), self.assertRaisesRegex(
             ValidationError, ".*wildcard search.*"
         ):
             self.run_test(query)

tests/sentry/api/test_event_search.py

@@ -397,7 +397,7 @@ class ParseSearchQueryBackendTest(SimpleTestCase):
             parse_search_query("min(measurements.size):3s")
 
     def test_is_query_unsupported(self):
-        with self.assertRaisesRegexp(
+        with self.assertRaisesRegex(
             InvalidSearchQuery, ".*queries are not supported in this search.*"
         ):
             parse_search_query("is:unassigned")

tests/sentry/db/models/fields/bitfield/test_bitfield.py

@@ -37,117 +37,117 @@ class BitHandlerTest(unittest.TestCase):
     def test_defaults(self):
         bithandler = BitHandler(0, ("FLAG_0", "FLAG_1", "FLAG_2", "FLAG_3"))
         # Default value of 0.
-        self.assertEquals(int(bithandler), 0)
+        self.assertEqual(int(bithandler), 0)
         # Test bit numbers.
-        self.assertEquals(int(bithandler.FLAG_0.number), 0)
-        self.assertEquals(int(bithandler.FLAG_1.number), 1)
-        self.assertEquals(int(bithandler.FLAG_2.number), 2)
-        self.assertEquals(int(bithandler.FLAG_3.number), 3)
+        self.assertEqual(int(bithandler.FLAG_0.number), 0)
+        self.assertEqual(int(bithandler.FLAG_1.number), 1)
+        self.assertEqual(int(bithandler.FLAG_2.number), 2)
+        self.assertEqual(int(bithandler.FLAG_3.number), 3)
         # Negative test non-existant key.
         self.assertRaises(AttributeError, lambda: bithandler.FLAG_4)
         # Test bool().
-        self.assertEquals(bool(bithandler.FLAG_0), False)
-        self.assertEquals(bool(bithandler.FLAG_1), False)
-        self.assertEquals(bool(bithandler.FLAG_2), False)
-        self.assertEquals(bool(bithandler.FLAG_3), False)
+        self.assertEqual(bool(bithandler.FLAG_0), False)
+        self.assertEqual(bool(bithandler.FLAG_1), False)
+        self.assertEqual(bool(bithandler.FLAG_2), False)
+        self.assertEqual(bool(bithandler.FLAG_3), False)
 
     def test_nonzero_default(self):
         bithandler = BitHandler(1, ("FLAG_0", "FLAG_1", "FLAG_2", "FLAG_3"))
-        self.assertEquals(bool(bithandler.FLAG_0), True)
-        self.assertEquals(bool(bithandler.FLAG_1), False)
-        self.assertEquals(bool(bithandler.FLAG_2), False)
-        self.assertEquals(bool(bithandler.FLAG_3), False)
+        self.assertEqual(bool(bithandler.FLAG_0), True)
+        self.assertEqual(bool(bithandler.FLAG_1), False)
+        self.assertEqual(bool(bithandler.FLAG_2), False)
+        self.assertEqual(bool(bithandler.FLAG_3), False)
 
         bithandler = BitHandler(2, ("FLAG_0", "FLAG_1", "FLAG_2", "FLAG_3"))
-        self.assertEquals(bool(bithandler.FLAG_0), False)
-        self.assertEquals(bool(bithandler.FLAG_1), True)
-        self.assertEquals(bool(bithandler.FLAG_2), False)
-        self.assertEquals(bool(bithandler.FLAG_3), False)
+        self.assertEqual(bool(bithandler.FLAG_0), False)
+        self.assertEqual(bool(bithandler.FLAG_1), True)
+        self.assertEqual(bool(bithandler.FLAG_2), False)
+        self.assertEqual(bool(bithandler.FLAG_3), False)
 
         bithandler = BitHandler(3, ("FLAG_0", "FLAG_1", "FLAG_2", "FLAG_3"))
-        self.assertEquals(bool(bithandler.FLAG_0), True)
-        self.assertEquals(bool(bithandler.FLAG_1), True)
-        self.assertEquals(bool(bithandler.FLAG_2), False)
-        self.assertEquals(bool(bithandler.FLAG_3), False)
+        self.assertEqual(bool(bithandler.FLAG_0), True)
+        self.assertEqual(bool(bithandler.FLAG_1), True)
+        self.assertEqual(bool(bithandler.FLAG_2), False)
+        self.assertEqual(bool(bithandler.FLAG_3), False)
 
         bithandler = BitHandler(4, ("FLAG_0", "FLAG_1", "FLAG_2", "FLAG_3"))
-        self.assertEquals(bool(bithandler.FLAG_0), False)
-        self.assertEquals(bool(bithandler.FLAG_1), False)
-        self.assertEquals(bool(bithandler.FLAG_2), True)
-        self.assertEquals(bool(bithandler.FLAG_3), False)
+        self.assertEqual(bool(bithandler.FLAG_0), False)
+        self.assertEqual(bool(bithandler.FLAG_1), False)
+        self.assertEqual(bool(bithandler.FLAG_2), True)
+        self.assertEqual(bool(bithandler.FLAG_3), False)
 
     def test_mutation(self):
         bithandler = BitHandler(0, ("FLAG_0", "FLAG_1", "FLAG_2", "FLAG_3"))
-        self.assertEquals(bool(bithandler.FLAG_0), False)
-        self.assertEquals(bool(bithandler.FLAG_1), False)
-        self.assertEquals(bool(bithandler.FLAG_2), False)
-        self.assertEquals(bool(bithandler.FLAG_3), False)
+        self.assertEqual(bool(bithandler.FLAG_0), False)
+        self.assertEqual(bool(bithandler.FLAG_1), False)
+        self.assertEqual(bool(bithandler.FLAG_2), False)
+        self.assertEqual(bool(bithandler.FLAG_3), False)
 
         bithandler = BitHandler(bithandler | 1, bithandler._keys)
-        self.assertEquals(bool(bithandler.FLAG_0), True)
-        self.assertEquals(bool(bithandler.FLAG_1), False)
-        self.assertEquals(bool(bithandler.FLAG_2), False)
-        self.assertEquals(bool(bithandler.FLAG_3), False)
+        self.assertEqual(bool(bithandler.FLAG_0), True)
+        self.assertEqual(bool(bithandler.FLAG_1), False)
+        self.assertEqual(bool(bithandler.FLAG_2), False)
+        self.assertEqual(bool(bithandler.FLAG_3), False)
 
         bithandler ^= 3
-        self.assertEquals(int(bithandler), 2)
+        self.assertEqual(int(bithandler), 2)
 
-        self.assertEquals(bool(bithandler & 1), False)
+        self.assertEqual(bool(bithandler & 1), False)
 
         bithandler.FLAG_0 = False
-        self.assertEquals(bithandler.FLAG_0, False)
+        self.assertEqual(bithandler.FLAG_0, False)
 
         bithandler.FLAG_1 = True
-        self.assertEquals(bithandler.FLAG_0, False)
-        self.assertEquals(bithandler.FLAG_1, True)
+        self.assertEqual(bithandler.FLAG_0, False)
+        self.assertEqual(bithandler.FLAG_1, True)
 
         bithandler.FLAG_2 = False
-        self.assertEquals(bithandler.FLAG_0, False)
-        self.assertEquals(bithandler.FLAG_1, True)
-        self.assertEquals(bithandler.FLAG_2, False)
+        self.assertEqual(bithandler.FLAG_0, False)
+        self.assertEqual(bithandler.FLAG_1, True)
+        self.assertEqual(bithandler.FLAG_2, False)
 
 
 class BitTest(unittest.TestCase):
     def test_int(self):
         bit = Bit(0)
-        self.assertEquals(int(bit), 1)
-        self.assertEquals(bool(bit), True)
+        self.assertEqual(int(bit), 1)
+        self.assertEqual(bool(bit), True)
         self.assertFalse(not bit)
 
     def test_comparison(self):
-        self.assertEquals(Bit(0), Bit(0))
-        self.assertNotEquals(Bit(1), Bit(0))
-        self.assertNotEquals(Bit(0, 0), Bit(0, 1))
-        self.assertEquals(Bit(0, 1), Bit(0, 1))
-        self.assertEquals(Bit(0), 1)
+        self.assertEqual(Bit(0), Bit(0))
+        self.assertNotEqual(Bit(1), Bit(0))
+        self.assertNotEqual(Bit(0, 0), Bit(0, 1))
+        self.assertEqual(Bit(0, 1), Bit(0, 1))
+        self.assertEqual(Bit(0), 1)
 
     def test_and(self):
-        self.assertEquals(1 & Bit(2), 0)
-        self.assertEquals(1 & Bit(0), 1)
-        self.assertEquals(1 & ~Bit(0), 0)
-        self.assertEquals(Bit(0) & Bit(2), 0)
-        self.assertEquals(Bit(0) & Bit(0), 1)
-        self.assertEquals(Bit(0) & ~Bit(0), 0)
+        self.assertEqual(1 & Bit(2), 0)
+        self.assertEqual(1 & Bit(0), 1)
+        self.assertEqual(1 & ~Bit(0), 0)
+        self.assertEqual(Bit(0) & Bit(2), 0)
+        self.assertEqual(Bit(0) & Bit(0), 1)
+        self.assertEqual(Bit(0) & ~Bit(0), 0)
 
     def test_or(self):
-        self.assertEquals(1 | Bit(2), 5)
-        self.assertEquals(1 | Bit(5), 33)
-        self.assertEquals(1 | ~Bit(2), -5)
-        self.assertEquals(Bit(0) | Bit(2), 5)
-        self.assertEquals(Bit(0) | Bit(5), 33)
-        self.assertEquals(Bit(0) | ~Bit(2), -5)
+        self.assertEqual(1 | Bit(2), 5)
+        self.assertEqual(1 | Bit(5), 33)
+        self.assertEqual(1 | ~Bit(2), -5)
+        self.assertEqual(Bit(0) | Bit(2), 5)
+        self.assertEqual(Bit(0) | Bit(5), 33)
+        self.assertEqual(Bit(0) | ~Bit(2), -5)
 
     def test_xor(self):
-        self.assertEquals(1 ^ Bit(2), 5)
-        self.assertEquals(1 ^ Bit(0), 0)
-        self.assertEquals(1 ^ Bit(1), 3)
-        self.assertEquals(1 ^ Bit(5), 33)
-        self.assertEquals(1 ^ ~Bit(2), -6)
-        self.assertEquals(Bit(0) ^ Bit(2), 5)
-        self.assertEquals(Bit(0) ^ Bit(0), 0)
-        self.assertEquals(Bit(0) ^ Bit(1), 3)
-        self.assertEquals(Bit(0) ^ Bit(5), 33)
-        self.assertEquals(Bit(0) ^ ~Bit(2), -6)
+        self.assertEqual(1 ^ Bit(2), 5)
+        self.assertEqual(1 ^ Bit(0), 0)
+        self.assertEqual(1 ^ Bit(1), 3)
+        self.assertEqual(1 ^ Bit(5), 33)
+        self.assertEqual(1 ^ ~Bit(2), -6)
+        self.assertEqual(Bit(0) ^ Bit(2), 5)
+        self.assertEqual(Bit(0) ^ Bit(0), 0)
+        self.assertEqual(Bit(0) ^ Bit(1), 3)
+        self.assertEqual(Bit(0) ^ Bit(5), 33)
+        self.assertEqual(Bit(0) ^ ~Bit(2), -6)
 
 
 class BitFieldTest(TestCase):
@@ -324,9 +324,7 @@ class BitFieldTest(TestCase):
         except ValueError:
             self.fail("It should work well with these flags")
 
-        self.assertEquals(
-            bf.flags, ["zero", "first", "second", "", "", "", "", "", "", "", "tenth"]
-        )
+        self.assertEqual(bf.flags, ["zero", "first", "second", "", "", "", "", "", "", "", "tenth"])
         self.assertRaises(ValueError, BitField, flags={})
         self.assertRaises(ValueError, BitField, flags={"wrongkey": "wrongkey"})
         self.assertRaises(ValueError, BitField, flags={"1": "non_int_key"})
@@ -338,14 +336,14 @@ class BitFieldTest(TestCase):
             )
 
         field = TestModel._meta.get_field("flags")
-        self.assertEquals(field.default, TestModel.flags.FLAG_1 | TestModel.flags.FLAG_2)
+        self.assertEqual(field.default, TestModel.flags.FLAG_1 | TestModel.flags.FLAG_2)
 
     def test_pickle_integration(self):
         inst = BitFieldTestModel.objects.create(flags=1)
         data = pickle.dumps(inst)
         inst = pickle.loads(data)
-        self.assertEquals(type(inst.flags), BitHandler)
-        self.assertEquals(int(inst.flags), 1)
+        self.assertEqual(type(inst.flags), BitHandler)
+        self.assertEqual(int(inst.flags), 1)
 
 
 class BitFieldSerializationTest(unittest.TestCase):

tests/sentry/mail/test_adapter.py

@@ -195,8 +195,8 @@ class MailAdapterNotifyTest(BaseMailAdapterTest):
             "Europe/Vienna"
         )
 
-        self.assertEquals(notification.project, self.project)
-        self.assertEquals(notification.get_reference(), group)
+        self.assertEqual(notification.project, self.project)
+        self.assertEqual(notification.get_reference(), group)
         assert notification.get_subject() == "BAR-1 - hello world"
 
     @mock.patch("sentry.notifications.notify.notify", side_effect=send_notification)

tests/sentry/manager/tests.py

@@ -5,9 +5,9 @@ from sentry.testutils import TestCase
 class SentryManagerTest(TestCase):
     def test_valid_only_message(self):
         event = Group.objects.from_kwargs(1, message="foo")
-        self.assertEquals(event.group.last_seen, event.datetime)
-        self.assertEquals(event.message, "foo")
-        self.assertEquals(event.project_id, 1)
+        self.assertEqual(event.group.last_seen, event.datetime)
+        self.assertEqual(event.message, "foo")
+        self.assertEqual(event.project_id, 1)
 
 
 class TeamManagerTest(TestCase):