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

@@ -504,7 +504,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))

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)]

babel/messages/frontend.py

@@ -173,7 +173,7 @@ class CompileCatalog(CommandMixin):
          'also include fuzzy translations'),
         ('statistics', None,
          'print statistics about translations'),
-    ]
+    ]  # fmt: skip
     boolean_options = ['use-fuzzy', 'statistics']
 
     def initialize_options(self):
@@ -207,30 +207,23 @@ def _run_domain(self, domain):
 
         if not self.input_file:
             if self.locale:
-                po_files.append((self.locale,
-                                 os.path.join(self.directory, self.locale,
-                                              'LC_MESSAGES',
-                                              f"{domain}.po")))
-                mo_files.append(os.path.join(self.directory, self.locale,
-                                             'LC_MESSAGES',
-                                             f"{domain}.mo"))
+                lc_messages_path = os.path.join(self.directory, self.locale, 'LC_MESSAGES')
+                po_files.append((self.locale, os.path.join(lc_messages_path, f"{domain}.po")))
+                mo_files.append(os.path.join(lc_messages_path, f"{domain}.mo"))
             else:
                 for locale in os.listdir(self.directory):
-                    po_file = os.path.join(self.directory, locale,
-                                           'LC_MESSAGES', f"{domain}.po")
+                    lc_messages_path = os.path.join(self.directory, locale, 'LC_MESSAGES')
+                    po_file = os.path.join(lc_messages_path, f"{domain}.po")
                     if os.path.exists(po_file):
                         po_files.append((locale, po_file))
-                        mo_files.append(os.path.join(self.directory, locale,
-                                                     'LC_MESSAGES',
-                                                     f"{domain}.mo"))
+                        mo_files.append(os.path.join(lc_messages_path, f"{domain}.mo"))
         else:
             po_files.append((self.locale, self.input_file))
             if self.output_file:
                 mo_files.append(self.output_file)
             else:
-                mo_files.append(os.path.join(self.directory, self.locale,
-                                             'LC_MESSAGES',
-                                             f"{domain}.mo"))
+                lc_messages_path = os.path.join(self.directory, self.locale, 'LC_MESSAGES')
+                mo_files.append(os.path.join(lc_messages_path, f"{domain}.mo"))
 
         if not po_files:
             raise OptionError('no message catalogs found')
@@ -347,7 +340,7 @@ class ExtractMessages(CommandMixin):
          'header comment for the catalog'),
         ('last-translator=', None,
          'set the name and email of the last translator in output'),
-    ]
+    ]  # fmt: skip
     boolean_options = [
         'no-default-keywords', 'no-location', 'omit-header', 'no-wrap',
         'sort-output', 'sort-by-file', 'strip-comments',
@@ -596,7 +589,7 @@ class InitCatalog(CommandMixin):
         ('no-wrap', None,
          'do not break long message lines, longer than the output line width, '
          'into several lines'),
-    ]
+    ]  # fmt: skip
     boolean_options = ['no-wrap']
 
     def initialize_options(self):
@@ -689,7 +682,7 @@ class UpdateCatalog(CommandMixin):
          'would be updated'),
         ('ignore-pot-creation-date=', None,
          'ignore changes to POT-Creation-Date when updating or checking'),
-    ]
+    ]  # fmt: skip
     boolean_options = [
         'omit-header', 'no-wrap', 'ignore-obsolete', 'init-missing',
         'no-fuzzy-matching', 'previous', 'update-header-comment',

babel/messages/jslexer.py

@@ -19,7 +19,7 @@
     '+=', '-=', '*=', '%=', '<<', '>>', '>>>', '<<=', '>>=',
     '>>>=', '&', '&=', '|', '|=', '&&', '||', '^', '^=', '(', ')',
     '[', ']', '{', '}', '!', '--', '++', '~', ',', ';', '.', ':',
-], key=len, reverse=True)
+], key=len, reverse=True)  # fmt: skip
 
 escapes: dict[str, str] = {'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r', 't': '\t'}
 
@@ -59,7 +59,7 @@ class Token(NamedTuple):
         '(?:[^'\\]*(?:\\.[^'\\]*)*)'  |
         "(?:[^"\\]*(?:\\.[^"\\]*)*)"
     )''', re.VERBOSE | re.DOTALL)),
-]
+]  # fmt: skip
 
 
 def get_rules(jsx: bool, dotted: bool, template_string: bool) -> list[tuple[str | None, re.Pattern[str]]]:

babel/messages/mofile.py

@@ -164,24 +164,19 @@ def write_mo(fileobj: SupportsWrite[bytes], catalog: Catalog, use_fuzzy: bool =
         # For each string, we need size and file offset.  Each string is NUL
         # terminated; the NUL does not count into the size.
         if message.pluralizable:
-            msgid = b'\x00'.join([
-                msgid.encode(catalog.charset) for msgid in message.id
-            ])
+            msgid = b'\x00'.join(msgid.encode(catalog.charset) for msgid in message.id)
             msgstrs = []
             for idx, string in enumerate(message.string):
                 if not string:
                     msgstrs.append(message.id[min(int(idx), 1)])
                 else:
                     msgstrs.append(string)
-            msgstr = b'\x00'.join([
-                msgstr.encode(catalog.charset) for msgstr in msgstrs
-            ])
+            msgstr = b'\x00'.join(msgstr.encode(catalog.charset) for msgstr in msgstrs)
         else:
             msgid = message.id.encode(catalog.charset)
             msgstr = message.string.encode(catalog.charset)
         if message.context:
-            msgid = b'\x04'.join([message.context.encode(catalog.charset),
-                                  msgid])
+            msgid = b'\x04'.join([message.context.encode(catalog.charset), msgid])
         offsets.append((len(ids), len(msgid), len(strs), len(msgstr)))
         ids += msgid + b'\x00'
         strs += msgstr + b'\x00'
@@ -200,11 +195,15 @@ def write_mo(fileobj: SupportsWrite[bytes], catalog: Catalog, use_fuzzy: bool =
         voffsets += [l2, o2 + valuestart]
     offsets = koffsets + voffsets
 
-    fileobj.write(struct.pack('Iiiiiii',
-                              LE_MAGIC,                   # magic
-                              0,                          # version
-                              len(messages),              # number of entries
-                              7 * 4,                      # start of key index
-                              7 * 4 + len(messages) * 8,  # start of value index
-                              0, 0,                       # size and offset of hash table
-                              ) + array.array.tobytes(array.array("i", offsets)) + ids + strs)
+    header = struct.pack(
+        'Iiiiiii',
+        LE_MAGIC,  # magic
+        0,  # version
+        len(messages),  # number of entries
+        7 * 4,  # start of key index
+        7 * 4 + len(messages) * 8,  # start of value index
+        0,
+        0,  # size and offset of hash table
+    )
+
+    fileobj.write(header + array.array.tobytes(array.array("i", offsets)) + ids + strs)

babel/messages/plurals.py

@@ -197,7 +197,7 @@
     'xh': (2, '(n != 1)'),
     # Chinese - From Pootle's PO's (modified)
     'zh': (1, '0'),
-}
+}  # fmt: skip
 
 
 DEFAULT_PLURAL: tuple[int, str] = (2, '(n != 1)')

babel/numbers.py

@@ -432,7 +432,7 @@ def get_exponential_symbol(
     :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
     """
     locale = Locale.parse(locale or LC_NUMERIC)
-    return _get_number_symbols(locale, numbering_system=numbering_system).get('exponential', 'E')
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('exponential', 'E')  # fmt: skip
 
 
 def get_group_symbol(
@@ -1054,9 +1054,12 @@ def parse_number(
     group_symbol = get_group_symbol(locale, numbering_system=numbering_system)
 
     if (
-        group_symbol in SPACE_CHARS and  # if the grouping symbol is a kind of space,
-        group_symbol not in string and  # and the string to be parsed does not contain it,
-        SPACE_CHARS_RE.search(string)  # but it does contain any other kind of space instead,
+        # if the grouping symbol is a kind of space,
+        group_symbol in SPACE_CHARS
+        # and the string to be parsed does not contain it,
+        and group_symbol not in string
+        # but it does contain any other kind of space instead,
+        and SPACE_CHARS_RE.search(string)
     ):
         # ... it's reasonable to assume it is taking the place of the grouping symbol.
         string = SPACE_CHARS_RE.sub(group_symbol, string)
@@ -1120,9 +1123,10 @@ def parse_decimal(
     decimal_symbol = get_decimal_symbol(locale, numbering_system=numbering_system)
 
     if not strict and (
-        group_symbol in SPACE_CHARS and  # if the grouping symbol is a kind of space,
-        group_symbol not in string and  # and the string to be parsed does not contain it,
-        SPACE_CHARS_RE.search(string)  # but it does contain any other kind of space instead,
+        group_symbol in SPACE_CHARS  # if the grouping symbol is a kind of space,
+        and group_symbol not in string  # and the string to be parsed does not contain it,
+        # but it does contain any other kind of space instead,
+        and SPACE_CHARS_RE.search(string)
     ):
         # ... it's reasonable to assume it is taking the place of the grouping symbol.
         string = SPACE_CHARS_RE.sub(group_symbol, string)