Apply manual formatting/fmt:skip to things that would be poorly autoformatted

Author: akx

babel/core.py

@@ -119,7 +119,7 @@ def get_global(key: _GLOBAL_KEY) -> Mapping[str, Any]:
     'mk': 'mk_MK', 'nl': 'nl_NL', 'nn': 'nn_NO', 'no': 'nb_NO', 'pl': 'pl_PL',
     'pt': 'pt_PT', 'ro': 'ro_RO', 'ru': 'ru_RU', 'sk': 'sk_SK', 'sl': 'sl_SI',
     'sv': 'sv_SE', 'th': 'th_TH', 'tr': 'tr_TR', 'uk': 'uk_UA',
-}
+}  # fmt: skip
 
 
 class UnknownLocaleError(Exception):
@@ -346,7 +346,8 @@ def parse(
                 f"variables for the API you tried to use."
             )
             if isinstance(identifier, str):
-                raise ValueError(msg)  # `parse_locale` would raise a ValueError, so let's do that here
+                # `parse_locale` would raise a ValueError, so let's do that here
+                raise ValueError(msg)
             raise TypeError(msg)
 
         if not isinstance(identifier, str):

babel/dates.py

@@ -41,7 +41,7 @@
     _Instant: TypeAlias = datetime.date | datetime.time | float | None
     _PredefinedTimeFormat: TypeAlias = Literal['full', 'long', 'medium', 'short']
     _Context: TypeAlias = Literal['format', 'stand-alone']
-    _DtOrTzinfo: TypeAlias = datetime.datetime | datetime.tzinfo | str | int | datetime.time | None
+    _DtOrTzinfo: TypeAlias = datetime.datetime | datetime.tzinfo | str | int | datetime.time | None  # fmt: skip
 
 # "If a given short metazone form is known NOT to be understood in a given
 #  locale and the parent locale has this value such that it would normally
@@ -1018,9 +1018,17 @@ def _format_fallback_interval(
 ) -> str:
     if skeleton in locale.datetime_skeletons:  # Use the given skeleton
         format = lambda dt: format_skeleton(skeleton, dt, tzinfo, locale=locale)
-    elif all((isinstance(d, datetime.date) and not isinstance(d, datetime.datetime)) for d in (start, end)):  # Both are just dates
+    elif all(
+        # Both are just dates
+        (isinstance(d, datetime.date) and not isinstance(d, datetime.datetime))
+        for d in (start, end)
+    ):
         format = lambda dt: format_date(dt, locale=locale)
-    elif all((isinstance(d, datetime.time) and not isinstance(d, datetime.date)) for d in (start, end)):  # Both are times
+    elif all(
+        # Both are times
+        (isinstance(d, datetime.time) and not isinstance(d, datetime.date))
+        for d in (start, end)
+    ):
         format = lambda dt: format_time(dt, tzinfo=tzinfo, locale=locale)
     else:
         format = lambda dt: format_datetime(dt, tzinfo=tzinfo, locale=locale)
@@ -1266,8 +1274,11 @@ def parse_date(
     use_predefined_format = format in ('full', 'long', 'medium', 'short')
     # we try ISO-8601 format first, meaning similar to formats
     # extended YYYY-MM-DD or basic YYYYMMDD
-    iso_alike = re.match(r'^(\d{4})-?([01]\d)-?([0-3]\d)$',
-                         string, flags=re.ASCII)  # allow only ASCII digits
+    iso_alike = re.match(
+        r'^(\d{4})-?([01]\d)-?([0-3]\d)$',
+        string,
+        flags=re.ASCII,  # allow only ASCII digits
+    )
     if iso_alike and use_predefined_format:
         try:
             return datetime.date(*map(int, iso_alike.groups()))
@@ -1637,35 +1648,24 @@ def format_timezone(self, char: str, num: int) -> str:
                 return get_timezone_gmt(value, width, locale=self.locale)
         # TODO: To add support for O:1
         elif char == 'v':
-            return get_timezone_name(value.tzinfo, width,
-                                     locale=self.locale)
+            return get_timezone_name(value.tzinfo, width, locale=self.locale)
         elif char == 'V':
             if num == 1:
-                return get_timezone_name(value.tzinfo, width,
-                                         uncommon=True, locale=self.locale)
+                return get_timezone_name(value.tzinfo, width, locale=self.locale)
             elif num == 2:
                 return get_timezone_name(value.tzinfo, locale=self.locale, return_zone=True)
             elif num == 3:
-                return get_timezone_location(value.tzinfo, locale=self.locale, return_city=True)
+                return get_timezone_location(value.tzinfo, locale=self.locale, return_city=True)  # fmt: skip
             return get_timezone_location(value.tzinfo, locale=self.locale)
-        # Included additional elif condition to add support for 'Xx' in timezone format
-        elif char == 'X':
-            if num == 1:
-                return get_timezone_gmt(value, width='iso8601_short', locale=self.locale,
-                                        return_z=True)
-            elif num in (2, 4):
-                return get_timezone_gmt(value, width='short', locale=self.locale,
-                                        return_z=True)
-            elif num in (3, 5):
-                return get_timezone_gmt(value, width='iso8601', locale=self.locale,
-                                        return_z=True)
-        elif char == 'x':
+        elif char in 'Xx':
+            return_z = char == 'X'
             if num == 1:
-                return get_timezone_gmt(value, width='iso8601_short', locale=self.locale)
+                width = 'iso8601_short'
             elif num in (2, 4):
-                return get_timezone_gmt(value, width='short', locale=self.locale)
+                width = 'short'
             elif num in (3, 5):
-                return get_timezone_gmt(value, width='iso8601', locale=self.locale)
+                width = 'iso8601'
+            return get_timezone_gmt(value, width=width, locale=self.locale, return_z=return_z)  # fmt: skip
 
     def format(self, value: SupportsInt, length: int) -> str:
         return '%0*d' % (length, value)
@@ -1739,7 +1739,7 @@ def get_week_number(self, day_of_period: int, day_of_week: int | None = None) ->
     's': [1, 2], 'S': None, 'A': None,                                  # second
     'z': [1, 2, 3, 4], 'Z': [1, 2, 3, 4, 5], 'O': [1, 4], 'v': [1, 4],  # zone
     'V': [1, 2, 3, 4], 'x': [1, 2, 3, 4, 5], 'X': [1, 2, 3, 4, 5],      # zone
-}
+}  # fmt: skip
 
 #: The pattern characters declared in the Date Field Symbol Table
 #: (https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table)
@@ -1967,11 +1967,11 @@ def match_skeleton(skeleton: str, options: Iterable[str], allow_different_fields
     if 'b' in skeleton and not any('b' in option for option in options):
         skeleton = skeleton.replace('b', '')
 
-    get_input_field_width = dict(t[1] for t in tokenize_pattern(skeleton) if t[0] == "field").get
+    get_input_field_width = dict(t[1] for t in tokenize_pattern(skeleton) if t[0] == "field").get  # fmt: skip
     best_skeleton = None
     best_distance = None
     for option in options:
-        get_opt_field_width = dict(t[1] for t in tokenize_pattern(option) if t[0] == "field").get
+        get_opt_field_width = dict(t[1] for t in tokenize_pattern(option) if t[0] == "field").get  # fmt: skip
         distance = 0
         for field in PATTERN_CHARS:
             input_width = get_input_field_width(field, 0)
@@ -1982,13 +1982,18 @@ def match_skeleton(skeleton: str, options: Iterable[str], allow_different_fields
                 if not allow_different_fields:  # This one is not okay
                     option = None
                     break
-                distance += 0x1000  # Magic weight constant for "entirely different fields"
-            elif field == 'M' and ((input_width > 2 and opt_width <= 2) or (input_width <= 2 and opt_width > 2)):
-                distance += 0x100  # Magic weight for "text turns into a number"
+                # Magic weight constant for "entirely different fields"
+                distance += 0x1000
+            elif field == 'M' and (
+                (input_width > 2 and opt_width <= 2) or (input_width <= 2 and opt_width > 2)
+            ):
+                # Magic weight constant for "text turns into a number"
+                distance += 0x100
             else:
                 distance += abs(input_width - opt_width)
 
-        if not option:  # We lost the option along the way (probably due to "allow_different_fields")
+        if not option:
+            # We lost the option along the way (probably due to "allow_different_fields")
             continue
 
         if not best_skeleton or distance < best_distance:

babel/localtime/_fallback.py

@@ -38,7 +38,7 @@ def tzname(self, dt: datetime.datetime) -> str:
     def _isdst(self, dt: datetime.datetime) -> bool:
         tt = (dt.year, dt.month, dt.day,
               dt.hour, dt.minute, dt.second,
-              dt.weekday(), 0, -1)
+              dt.weekday(), 0, -1)  # fmt: skip
         stamp = time.mktime(tt)
         tt = time.localtime(stamp)
         return tt.tm_isdst > 0

babel/messages/catalog.py

@@ -516,7 +516,7 @@ def _get_mime_headers(self) -> list[tuple[str, str]]:
             ('POT-Creation-Date', format_datetime(self.creation_date, 'yyyy-MM-dd HH:mmZ', locale='en')),
             ('PO-Revision-Date', revision_date),
             ('Last-Translator', self.last_translator),
-        ]
+        ]  # fmt: skip
         if self.locale_identifier:
             headers.append(('Language', str(self.locale_identifier)))
         headers.append(('Language-Team', language_team))
@@ -739,13 +739,13 @@ def __setitem__(self, id: _MessageID, message: Message) -> None:
                 current.id = message.id
                 current.string = message.string
             current.locations = list(dict.fromkeys([*current.locations, *message.locations]))
-            current.auto_comments = list(dict.fromkeys([*current.auto_comments, *message.auto_comments]))
-            current.user_comments = list(dict.fromkeys([*current.user_comments, *message.user_comments]))
+            current.auto_comments = list(dict.fromkeys([*current.auto_comments, *message.auto_comments]))  # fmt:skip
+            current.user_comments = list(dict.fromkeys([*current.user_comments, *message.user_comments]))  # fmt:skip
             current.flags |= message.flags
         elif id == '':
             # special treatment for the header message
             self.mime_headers = message_from_string(message.string).items()
-            self.header_comment = "\n".join([f"# {c}".rstrip() for c in message.user_comments])
+            self.header_comment = "\n".join(f"# {c}".rstrip() for c in message.user_comments)
             self.fuzzy = message.fuzzy
         else:
             if isinstance(id, (list, tuple)):

babel/messages/checkers.py

@@ -27,8 +27,7 @@ def num_plurals(catalog: Catalog | None, message: Message) -> None:
     """Verify the number of plurals in the translation."""
     if not message.pluralizable:
         if not isinstance(message.string, str):
-            raise TranslationError("Found plural forms for non-pluralizable "
-                                   "message")
+            raise TranslationError("Found plural forms for non-pluralizable message")
         return
 
     # skip further tests if no catalog is provided.
@@ -39,8 +38,9 @@ def num_plurals(catalog: Catalog | None, message: Message) -> None:
     if not isinstance(msgstrs, (list, tuple)):
         msgstrs = (msgstrs,)
     if len(msgstrs) != catalog.num_plurals:
-        raise TranslationError("Wrong number of plural forms (expected %d)" %
-                               catalog.num_plurals)
+        raise TranslationError(
+            f"Wrong number of plural forms (expected {catalog.num_plurals})",
+        )
 
 
 def python_format(catalog: Catalog | None, message: Message) -> None:
@@ -137,13 +137,13 @@ def _check_positional(results: list[tuple[str, str]]) -> bool:
     # same number of format chars and those must be compatible
     if a_positional:
         if len(a) != len(b):
-            raise TranslationError('positional format placeholders are '
-                                   'unbalanced')
+            raise TranslationError('positional format placeholders are unbalanced')
         for idx, ((_, first), (_, second)) in enumerate(zip(a, b)):
             if not _compatible(first, second):
-                raise TranslationError('incompatible format for placeholder '
-                                       '%d: %r and %r are not compatible' %
-                                       (idx + 1, first, second))
+                raise TranslationError(
+                    f'incompatible format for placeholder {idx + 1:d}: '
+                    f'{first!r} and {second!r} are not compatible',
+                )
 
     # otherwise the second string must not have names the first one
     # doesn't have and the types of those included must be compatible

babel/messages/extract.py

@@ -62,7 +62,7 @@ def tell(self) -> int: ...
     _Keyword: TypeAlias = dict[int | None, _SimpleKeyword] | _SimpleKeyword
 
     # 5-tuple of (filename, lineno, messages, comments, context)
-    _FileExtractionResult: TypeAlias = tuple[str, int, str | tuple[str, ...], list[str], str | None]
+    _FileExtractionResult: TypeAlias = tuple[str, int, str | tuple[str, ...], list[str], str | None]  # fmt: skip
 
     # 4-tuple of (lineno, message, comments, context)
     _ExtractionResult: TypeAlias = tuple[int, str | tuple[str, ...], list[str], str | None]
@@ -72,7 +72,7 @@ def tell(self) -> int: ...
     _CallableExtractionMethod: TypeAlias = Callable[
         [_FileObj | IO[bytes], Mapping[str, _Keyword], Collection[str], Mapping[str, Any]],
         Iterable[_ExtractionResult],
-    ]
+    ]  # fmt: skip
 
     _ExtractionMethod: TypeAlias = _CallableExtractionMethod | str
 
@@ -696,9 +696,12 @@ def extract_javascript(
         lineno=lineno,
     ):
         if (  # Turn keyword`foo` expressions into keyword("foo") calls:
-            funcname and  # have a keyword...
-            (last_token and last_token.type == 'name') and  # we've seen nothing after the keyword...
-            token.type == 'template_string'  # this is a template string
+            # have a keyword...
+            funcname
+            # and we've seen nothing after the keyword...
+            and (last_token and last_token.type == 'name')
+            # and this is a template string
+            and token.type == 'template_string'
         ):
             message_lineno = token.lineno
             messages = [unquote_string(token.value)]