Simplify N802 suppression for common.py (#2880)

arkid15r · web-flow · commit 20d9bc3789e2 · 2025-09-02T16:05:48.000Z
diff --git a/pyproject.toml b/pyproject.toml
@@ -57,6 +57,7 @@ target-version = "py39"
 line-length = 99
 lint.select = [ "E4", "E5", "E7", "E9", "F", "N", "PLE", "S", "T", "TC", "UP", "W" ]
 lint.per-file-ignores."scripts/generate_release_notes.py" = [ "T201" ]
+lint.per-file-ignores."tests/common.py" = [ "N802" ]
 lint.per-file-ignores."tests/test_holiday_base.py" = [ "S301" ]
 lint.flake8-errmsg.max-string-length = 99
 
diff --git a/tests/common.py b/tests/common.py
@@ -121,7 +121,7 @@ def _verify_type(self, holidays):
             "`holidays` object must be a subclass of `HolidayBase`",
         )
 
-    def assertAliases(self, cls, *aliases):  # noqa: N802
+    def assertAliases(self, cls, *aliases):
         """Assert aliases match."""
         self.assertTrue(
             issubclass(cls, HolidayBase), "The entity object must be a subclass of `HolidayBase`"
@@ -132,7 +132,7 @@ def assertAliases(self, cls, *aliases):  # noqa: N802
             self.assertIsNotNone(alias, type_error_message)
             self.assertTrue(issubclass(alias, cls), type_error_message)
 
-    def assertDeprecatedSubdivisions(self, message):  # noqa: N802
+    def assertDeprecatedSubdivisions(self, message):
         warnings.simplefilter("always", category=DeprecationWarning)
         for subdiv in self.test_class._deprecated_subdivisions:
             with warnings.catch_warnings(record=True) as ctx:
@@ -142,24 +142,24 @@ def assertDeprecatedSubdivisions(self, message):  # noqa: N802
                 self.assertIn(message, str(warning.message))
 
     # Holiday.
-    def _assertHoliday(self, instance_name, *args):  # noqa: N802
+    def _assertHoliday(self, instance_name, *args):
         """Helper: assert each date is a holiday."""
         holidays, dates = self._parse_arguments(args, instance_name=instance_name)
         self._verify_type(holidays)
 
         for dt in dates:
             self.assertIn(dt, holidays, dt)
 
-    def assertHoliday(self, *args):  # noqa: N802
+    def assertHoliday(self, *args):
         """Assert each date is a holiday."""
         self._assertHoliday("holidays", *args)
 
-    def assertNonObservedHoliday(self, *args):  # noqa: N802
+    def assertNonObservedHoliday(self, *args):
         """Assert each date is a non-observed holiday."""
         self._assertHoliday("holidays_non_observed", *args)
 
     # Holiday dates.
-    def _assertHolidayDates(self, instance_name, *args):  # noqa: N802
+    def _assertHolidayDates(self, instance_name, *args):
         """Helper: assert holiday dates exactly match expected dates."""
         holidays, dates = self._parse_arguments(args, instance_name=instance_name)
         self._verify_type(holidays)
@@ -170,16 +170,16 @@ def _assertHolidayDates(self, instance_name, *args):  # noqa: N802
 
         self.assertEqual(len(dates), len(holidays.keys()), set(dates).difference(holidays.keys()))
 
-    def assertHolidayDates(self, *args):  # noqa: N802
+    def assertHolidayDates(self, *args):
         """Assert holiday dates exactly match expected dates."""
         self._assertHolidayDates("holidays", *args)
 
-    def assertNonObservedHolidayDates(self, *args):  # noqa: N802
+    def assertNonObservedHolidayDates(self, *args):
         """Assert holiday dates exactly match expected dates."""
         self._assertHolidayDates("holidays_non_observed", *args)
 
     # Holiday name.
-    def _assertHolidayName(self, name, instance_name, *args):  # noqa: N802
+    def _assertHolidayName(self, name, instance_name, *args):
         """Helper: assert either a holiday with a specific name exists or
         each holiday name matches an expected one depending on the args nature.
         """
@@ -195,20 +195,20 @@ def _assertHolidayName(self, name, instance_name, *args):  # noqa: N802
         else:
             raise ValueError(f"The {arg} wasn't caught by `assertHolidayName()`")
 
-    def assertHolidayName(self, name, *args):  # noqa: N802
+    def assertHolidayName(self, name, *args):
         """Assert either a holiday with a specific name exists or
         each holiday name matches an expected one.
         """
         self._assertHolidayName(name, "holidays", *args)
 
-    def assertNonObservedHolidayName(self, name, *args):  # noqa: N802
+    def assertNonObservedHolidayName(self, name, *args):
         """Assert either a non-observed holiday with a specific name exists or
         each non-observed holiday name matches an expected one.
         """
         self._assertHolidayName(name, "holidays_non_observed", *args)
 
     # Holidays.
-    def _assertHolidays(self, instance_name, *args):  # noqa: N802
+    def _assertHolidays(self, instance_name, *args):
         """Helper: assert holidays exactly match expected holidays."""
         holidays, expected_holidays = self._parse_arguments(
             args, expand_items=False, instance_name=instance_name
@@ -228,15 +228,15 @@ def _assertHolidays(self, instance_name, *args):  # noqa: N802
             ),
         )
 
-    def assertHolidays(self, *args):  # noqa: N802
+    def assertHolidays(self, *args):
         """Assert holidays exactly match expected holidays."""
         self._assertHolidays("holidays", *args)
 
-    def assertNonObservedHolidays(self, *args):  # noqa: N802
+    def assertNonObservedHolidays(self, *args):
         """Assert non-observed holidays exactly match expected holidays."""
         self._assertHolidays("holidays_non_observed", *args)
 
-    def _assertHolidayNameCount(self, name, count, instance_name, *args):  # noqa: N802
+    def _assertHolidayNameCount(self, name, count, instance_name, *args):
         """Helper: assert number of holidays with a specific name in every year matches
         expected.
         """
@@ -255,34 +255,34 @@ def _assertHolidayNameCount(self, name, count, instance_name, *args):  # noqa: N
                 f"`{name}` occurs {holiday_count} times in year {year}, should be {count}",
             )
 
-    def assertHolidayNameCount(self, name, count, *args):  # noqa: N802
+    def assertHolidayNameCount(self, name, count, *args):
         """Assert number of holidays with a specific name in every year matches expected."""
         self._assertHolidayNameCount(name, count, "holidays", *args)
 
-    def assertNonObservedHolidayNameCount(self, name, count, *args):  # noqa: N802
+    def assertNonObservedHolidayNameCount(self, name, count, *args):
         """Assert number of non-observed holidays with a specific name in every year
         matches expected.
         """
         self._assertHolidayNameCount(name, count, "holidays_non_observed", *args)
 
     # No holiday.
-    def _assertNoHoliday(self, instance_name, *args):  # noqa: N802
+    def _assertNoHoliday(self, instance_name, *args):
         """Helper: assert each date is not a holiday."""
         holidays, dates = self._parse_arguments(args, instance_name=instance_name)
 
         for dt in dates:
             self.assertNotIn(dt, holidays, dt)
 
-    def assertNoHoliday(self, *args):  # noqa: N802
+    def assertNoHoliday(self, *args):
         """Assert each date is not a holiday."""
         self._assertNoHoliday("holidays", *args)
 
-    def assertNoNonObservedHoliday(self, *args):  # noqa: N802
+    def assertNoNonObservedHoliday(self, *args):
         """Assert each date is not a non-observed holiday."""
         self._assertNoHoliday("holidays_non_observed", *args)
 
     # No holiday name.
-    def _assertNoHolidayName(self, name, instance_name, *args):  # noqa: N802
+    def _assertNoHolidayName(self, name, instance_name, *args):
         """Helper: assert a holiday with a specific name doesn't exist."""
         holidays, items = self._parse_arguments(
             args, instance_name=instance_name, raise_on_empty=False
@@ -302,16 +302,16 @@ def _assertNoHolidayName(self, name, instance_name, *args):  # noqa: N802
         else:
             raise ValueError(f"The {arg} wasn't caught by `assertNoHolidayName()`")
 
-    def assertNoHolidayName(self, name, *args):  # noqa: N802
+    def assertNoHolidayName(self, name, *args):
         """Assert a holiday with a specific name doesn't exist."""
         self._assertNoHolidayName(name, "holidays", *args)
 
-    def assertNoNonObservedHolidayName(self, name, *args):  # noqa: N802
+    def assertNoNonObservedHolidayName(self, name, *args):
         """Assert a non-observed holiday with a specific name doesn't exist."""
         self._assertNoHolidayName(name, "holidays_non_observed", *args)
 
     # No holidays.
-    def _assertNoHolidays(self, instance_name, *args):  # noqa: N802
+    def _assertNoHolidays(self, instance_name, *args):
         """Helper: assert holidays dict is empty."""
         holidays, _ = self._parse_arguments(
             args, instance_name=instance_name, raise_on_empty=False
@@ -321,15 +321,15 @@ def _assertNoHolidays(self, instance_name, *args):  # noqa: N802
         self.assertFalse(holidays)
         self.assertEqual(0, len(holidays))
 
-    def assertNoHolidays(self, *args):  # noqa: N802
+    def assertNoHolidays(self, *args):
         """Assert holidays dict is empty."""
         self._assertNoHolidays("holidays", *args)
 
-    def assertNoNonObservedHolidays(self, *args):  # noqa: N802
+    def assertNoNonObservedHolidays(self, *args):
         """Assert non-observed holidays dict is empty."""
         self._assertNoHolidays("holidays_non_observed", *args)
 
-    def _assertLocalizedHolidays(self, localized_holidays, language=None):  # noqa: N802
+    def _assertLocalizedHolidays(self, localized_holidays, language=None):
         """Helper: assert localized holidays match expected names."""
         instance = self.test_class(
             years=localized_holidays[0][0].split("-")[0],
@@ -356,7 +356,7 @@ def _assertLocalizedHolidays(self, localized_holidays, language=None):  # noqa:
             f"Please make sure all holiday names are localized: {actual_holidays}",
         )
 
-    def assertLocalizedHolidays(self, *args):  # noqa: N802
+    def assertLocalizedHolidays(self, *args):
         """Assert localized holidays match expected names."""
         arg = args[0]
         is_string = isinstance(arg, str)
@@ -442,7 +442,7 @@ def test_code(self):
 class SundayHolidays(TestCase):
     """Common class to test countries with Sundays as a holidays."""
 
-    def assertSundays(self, cls):  # noqa: N802
+    def assertSundays(self, cls):
         holidays = cls(years=1989, include_sundays=True)
         self.assertHoliday(holidays, "1989-12-31")
         self.assertEqual(53, len([s for s in holidays if s.weekday() == SUN]))
@@ -481,7 +481,7 @@ class WorkingDayTests(TestCase):
     """Common class for testing entity holidays substituted from non-working days."""
 
     # Workday.
-    def _assertWorkingDay(self, instance_name, *args):  # noqa: N802
+    def _assertWorkingDay(self, instance_name, *args):
         """Helper: assert each date is a working day."""
         holidays, dates = self._parse_arguments(args, instance_name=instance_name)
         self._verify_type(holidays)
@@ -490,10 +490,10 @@ def _assertWorkingDay(self, instance_name, *args):  # noqa: N802
             self.assertTrue(holidays._is_weekend(parse(dt)))
             self.assertTrue(holidays.is_working_day(dt))
 
-    def assertWorkingDay(self, *args):  # noqa: N802
+    def assertWorkingDay(self, *args):
         """Assert each date is a working day."""
         self._assertWorkingDay("holidays", *args)
 
-    def assertNonObservedWorkingDay(self, *args):  # noqa: N802
+    def assertNonObservedWorkingDay(self, *args):
         """Assert each date is a non-observed working day."""
         self._assertWorkingDay("holidays_non_observed", *args)
