Use standard property annotations; get rid of :type: and :rtype: comments

babel/core.py

@@ -509,9 +509,9 @@ def get_display_name(self, locale: Locale | str | None = None) -> str | None:
                 retval += f" ({detail_string})"
         return retval
 
-    display_name = property(
-        get_display_name,
-        doc="""\
+    @property
+    def display_name(self) -> str | None:
+        """
         The localized display name of the locale.
 
         >>> Locale('en').display_name
@@ -520,10 +520,8 @@ def get_display_name(self, locale: Locale | str | None = None) -> str | None:
         'English (United States)'
         >>> Locale('sv').display_name
         'svenska'
-
-        :type: `unicode`
-        """,
-    )
+        """
+        return self.get_display_name()
 
     def get_language_name(self, locale: Locale | str | None = None) -> str | None:
         """Return the language of this locale in the given locale.
@@ -540,15 +538,15 @@ def get_language_name(self, locale: Locale | str | None = None) -> str | None:
         locale = Locale.parse(locale)
         return locale.languages.get(self.language)
 
-    language_name = property(
-        get_language_name,
-        doc="""\
+    @property
+    def language_name(self) -> str | None:
+        """
         The localized language name of the locale.
 
         >>> Locale('en', 'US').language_name
         'English'
-    """,
-    )
+        """
+        return self.get_language_name()
 
     def get_territory_name(self, locale: Locale | str | None = None) -> str | None:
         """Return the territory name in the given locale."""
@@ -557,15 +555,15 @@ def get_territory_name(self, locale: Locale | str | None = None) -> str | None:
         locale = Locale.parse(locale)
         return locale.territories.get(self.territory or '')
 
-    territory_name = property(
-        get_territory_name,
-        doc="""\
+    @property
+    def territory_name(self) -> str | None:
+        """
         The localized territory name of the locale if available.
 
         >>> Locale('de', 'DE').territory_name
         'Deutschland'
-    """,
-    )
+        """
+        return self.get_territory_name()
 
     def get_script_name(self, locale: Locale | str | None = None) -> str | None:
         """Return the script name in the given locale."""
@@ -574,15 +572,15 @@ def get_script_name(self, locale: Locale | str | None = None) -> str | None:
         locale = Locale.parse(locale)
         return locale.scripts.get(self.script or '')
 
-    script_name = property(
-        get_script_name,
-        doc="""\
+    @property
+    def script_name(self) -> str | None:
+        """
         The localized script name of the locale if available.
 
         >>> Locale('sr', 'ME', script='Latn').script_name
         'latinica'
-    """,
-    )
+        """
+        return self.get_script_name()
 
     @property
     def english_name(self) -> str | None:
@@ -592,8 +590,7 @@ def english_name(self) -> str | None:
         'German'
         >>> Locale('de', 'DE').english_name
         'German (Germany)'
-
-        :type: `unicode`"""
+        """
         return self.get_display_name(Locale('en'))
 
     # { General Locale Display Names

babel/dates.py

@@ -146,9 +146,7 @@ def _get_datetime(instant: _Instant) -> datetime.datetime:
     True
 
     :param instant: date, time, datetime, integer, float or None
-    :type instant: date|time|datetime|int|float|None
     :return: a datetime
-    :rtype: datetime
     """
     if instant is None:
         return datetime.datetime.now(UTC).replace(tzinfo=None)
@@ -1834,8 +1832,6 @@ def tokenize_pattern(pattern: str) -> list[tuple[str, str | tuple[str, int]]]:
     For "field" tokens, the value is a tuple of (field character, repetition count).
 
     :param pattern: Pattern string
-    :type pattern: str
-    :rtype: list[tuple]
     """
     result = []
     quotebuf = None
@@ -1895,9 +1891,6 @@ def untokenize_pattern(tokens: Iterable[tuple[str, str | tuple[str, int]]]) -> s
     Turn a date format pattern token stream back into a string.
 
     This is the reverse operation of ``tokenize_pattern``.
-
-    :type tokens: Iterable[tuple]
-    :rtype: str
     """
     output = []
     for tok_type, tok_value in tokens:
@@ -1971,13 +1964,9 @@ def match_skeleton(
     'hmv'
 
     :param skeleton: The skeleton to match
-    :type skeleton: str
     :param options: An iterable of other skeletons to match against
-    :type options: Iterable[str]
     :param allow_different_fields: Whether to allow a match that uses different fields
                                    than the skeleton requested.
-    :type allow_different_fields: bool
-
     :return: The closest skeleton match, or if no match was found, None.
     :rtype: str|None
     """

babel/languages.py

@@ -21,13 +21,9 @@ def get_official_languages(
                  by Babel.  If you need scientifically accurate information, use another source!
 
     :param territory: Territory code
-    :type territory: str
     :param regional: Whether to return regionally official languages too
-    :type regional: bool
     :param de_facto: Whether to return de-facto official languages too
-    :type de_facto: bool
     :return: Tuple of language codes
-    :rtype: tuple[str]
     """
 
     territory = str(territory).upper()
@@ -70,9 +66,7 @@ def get_territory_language_info(
     See https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html
 
     :param territory: Territory code
-    :type territory: str
     :return: Language information dictionary
-    :rtype: dict[str, dict]
     """
     territory = str(territory).upper()
     return get_global("territory_languages").get(territory, {}).copy()

babel/localedata.py

@@ -251,7 +251,6 @@ def resolve(self, data: Mapping[str | int | None, Any]) -> Mapping[str | int | N
         that second alias will also be resolved.
 
         :param data: the locale data
-        :type data: `dict`
         """
         base = data
         for key in self.keys: