Repository: joke2k/faker
Pull request #2054 (2024-05-29 13:34:45)

Added support for Nigerian Yoruba names and surnames (yo_NG)
### What does this change

Add Added support for Nigerian Yoruba names and surnames.



Patch:
diff --git a/.bumpversion.cfg b/.bumpversion.cfg
index d14375d8..3377e576 100644
--- a/.bumpversion.cfg
+++ b/.bumpversion.cfg
@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 25.3.0
+current_version = 25.8.0
 files = VERSION faker/__init__.py docs/conf.py
 commit = True
 tag = True
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f88baa26..cab81022 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,26 @@
 ## Changelog
 
+
+### [v25.8.0 - 2024-05-07](https://github.com/joke2k/faker/compare/v25.7.0..v25.8.0)
+
+* Add handshake emoji with different color variations to emoji provider list. Thanks @tamkc.
+
+### [v25.7.0 - 2024-05-07](https://github.com/joke2k/faker/compare/v25.6.0..v25.7.0)
+
+* Add missing translation for countries in `pt-BR`. Thanks @LeonardoFurtado.
+
+### [v25.6.0 - 2024-05-06](https://github.com/joke2k/faker/compare/v25.5.0...v25.6.0)
+
+* Fix data in geo for `pl_PL`. Thanks @george0st, @mgorny.
+
+### [v25.5.0 - 2024-05-04](https://github.com/joke2k/faker/compare/v25.4.0...v25.5.0)
+
+* Fix data in geo for `pl_PL`. Thanks @george0st.
+
+### [v25.4.0 - 2024-05-03](https://github.com/joke2k/faker/compare/v25.3.0...v25.4.0)
+
+* Add landmarks in `geo` for `pl_PL`. Thanks @george0st.
+
 ### [v25.3.0 - 2024-05-28](https://github.com/joke2k/faker/compare/v25.2.0...v25.3.0)
 
 * Add more iOS versions to `user_agent`. Thanks @george0st.
diff --git a/CONTRIBUTING.rst b/CONTRIBUTING.rst
index fd48e03e..35997b89 100644
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@@ -11,6 +11,7 @@ Getting Started
 -  Clearly describe the issue including steps to reproduce when it is a bug.
 -  Make sure you fill in the earliest version that you know has the issue.
 -  Fork the repository on GitHub
+-  Please only make changes or add data to locales you're familiar with.
 
 Making Changes
 --------------
diff --git a/VERSION b/VERSION
index b44fe911..11d4ad6c 100644
--- a/VERSION
+++ b/VERSION
@@ -1,1 +1,1 @@
-25.3.0
+25.8.0
diff --git a/docs/conf.py b/docs/conf.py
index ec61f861..8d5933df 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -51,9 +51,9 @@ copyright = f"2014-{datetime.now().year}, Daniele Faraglia"
 # built documents.
 #
 # The short X.Y version.
-version = "25.3.0"
+version = "25.8.0"
 # The full version, including alpha/beta/rc tags.
-release = "25.3.0"
+release = "25.8.0"
 
 # The language for content autogenerated by Sphinx. Refer to documentation
 # for a list of supported languages.
diff --git a/faker/__init__.py b/faker/__init__.py
index 49f998c7..c379fd59 100644
--- a/faker/__init__.py
+++ b/faker/__init__.py
@@ -2,6 +2,6 @@ from faker.factory import Factory
 from faker.generator import Generator
 from faker.proxy import Faker
 
-VERSION = "25.3.0"
+VERSION = "25.8.0"
 
 __all__ = ("Factory", "Generator", "Faker")
diff --git a/faker/providers/address/it_IT/__init__.py b/faker/providers/address/it_IT/__init__.py
index 6ba2a908..ec43ca1c 100644
--- a/faker/providers/address/it_IT/__init__.py
+++ b/faker/providers/address/it_IT/__init__.py
@@ -4,11 +4,7 @@ from .. import Provider as AddressProvider
 
 
 def getcities(fulldict):
-    cities = []
-    for cap in fulldict:
-        for c in fulldict[cap]:
-            cities.append(c[0]) if c[0] not in cities else cities
-    return cities
+    return list({c[0] for _cap, cities in fulldict.items() for c in cities})
 
 
 class Provider(AddressProvider):
diff --git a/faker/providers/address/pt_BR/__init__.py b/faker/providers/address/pt_BR/__init__.py
index 91ba030c..69ca1ebe 100644
--- a/faker/providers/address/pt_BR/__init__.py
+++ b/faker/providers/address/pt_BR/__init__.py
@@ -685,7 +685,7 @@ class Provider(AddressProvider):
         "Gibraltar",
         "Granada",
         "Grécia",
-        "Gronelândia",
+        "Groenlândia",
         "Guam",
         "Guatemala",
         "Guernsey",
@@ -736,14 +736,14 @@ class Provider(AddressProvider):
         "Lituânia",
         "Luxemburgo",
         "Macau",
-        "Macedónia do Norte",
-        "Madagáscar",
+        "Macedônia do Norte",
+        "Madagascar",
         "Malásia",
         "Malávi",
         "Maldivas",
         "Mali",
         "Malta",
-        "Man, Isle of",
+        "Ilha de Man",
         "Marianas do Norte",
         "Marrocos",
         "Maurícia",
@@ -841,10 +841,10 @@ class Provider(AddressProvider):
         "Vaticano",
         "Venezuela",
         "Vietnam",
-        "Wake Island",
+        "Ilha Wake",
         "Wallis e Futuna",
         "Zâmbia",
-        "Zimbabué",
+        "Zimbábue",
     )
 
     estados = (
diff --git a/faker/providers/emoji/__init__.py b/faker/providers/emoji/__init__.py
index 2e813f9e..6d293116 100644
--- a/faker/providers/emoji/__init__.py
+++ b/faker/providers/emoji/__init__.py
@@ -334,6 +334,11 @@ class Provider(BaseProvider):
         "🤲🏾",
         "🤲🏿",
         "🤝",
+        "🤝🏻",
+        "🤝🏼",
+        "🤝🏽",
+        "🤝🏾",
+        "🤝🏿",
         "🙏",
         "🙏🏻",
         "🙏🏼",
diff --git a/faker/providers/file/__init__.py b/faker/providers/file/__init__.py
index 80ca1d13..9634001f 100644
--- a/faker/providers/file/__init__.py
+++ b/faker/providers/file/__init__.py
@@ -337,7 +337,7 @@ class Provider(BaseProvider):
         if prefix is None:
             prefix = self.random_element(self.unix_device_prefixes)
         suffix: str = self.random_element(string.ascii_lowercase)
-        path = "/dev/{}{}".format(prefix, suffix)
+        path = f"/dev/{prefix}{suffix}"
         return path
 
     def unix_partition(self, prefix: Optional[str] = None) -> str:
diff --git a/faker/providers/geo/pl_PL/__init__.py b/faker/providers/geo/pl_PL/__init__.py
index dcee47a8..45428438 100644
--- a/faker/providers/geo/pl_PL/__init__.py
+++ b/faker/providers/geo/pl_PL/__init__.py
@@ -5,9 +5,9 @@ class Provider(GeoProvider):
     # Source:
     #   https://latitude.to/map/pl/poland/cities/
     land_coords = (
-        ("52.22977", "21.01178", "Warsaw", "PL", "Europe/Warsaw"),
+        ("52.22977", "21.01178", "Warszawa", "PL", "Europe/Warsaw"),
         ("51.75", "19.46667", "Łódź", "PL", "Europe/Warsaw"),
-        ("50.06143", "19.93658", "Krakow", "PL", "Europe/Warsaw"),
+        ("50.06143", "19.93658", "Kraków", "PL", "Europe/Warsaw"),
         ("51.1", "17.03333", "Wrocław", "PL", "Europe/Warsaw"),
         ("52.40692", "16.92993", "Poznań", "PL", "Europe/Warsaw"),
         ("54.35205", "18.64637", "Gdańsk", "PL", "Europe/Warsaw"),
@@ -20,10 +20,29 @@ class Provider(GeoProvider):
         ("50.79646", "19.12409", "Częstochowa", "PL", "Europe/Warsaw"),
         ("50.28682", "19.10385", "Sosnowiec", "PL", "Europe/Warsaw"),
         ("51.40253", "21.14714", "Radom", "PL", "Europe/Warsaw"),
-        ("52.1934", "21.03487", "Mokotów", "PL", "Europe/Warsaw"),
         ("53.01375", "18.59814", "Toruń", "PL", "Europe/Warsaw"),
         ("50.87033", "20.62752", "Kielce", "PL", "Europe/Warsaw"),
         ("50.29761", "18.67658", "Gliwice", "PL", "Europe/Warsaw"),
         ("50.32492", "18.78576", "Zabrze", "PL", "Europe/Warsaw"),
         ("50.34802", "18.93282", "Bytom", "PL", "Europe/Warsaw"),
+        ("49.82245", "19.04686", "Bielsko-Biała", "PL", "Europe/Warsaw"),
+        ("53.77995", "20.49416", "Olsztyn", "PL", "Europe/Warsaw"),
+        ("50.04132", "21.99901", "Rzeszów", "PL", "Europe/Warsaw"),
+        ("50.2584", "18.85632", "Ruda Śląska", "PL", "Europe/Warsaw"),
+        ("50.09713", "18.54179", "Rybnik", "PL", "Europe/Warsaw"),
+        ("50.31818", "19.2374", "Dąbrowa Górnicza", "PL", "Europe/Warsaw"),
+        ("50.13717", "18.96641", "Tychy", "PL", "Europe/Warsaw"),
+        ("50.67211", "17.92533", "Opole", "PL", "Europe/Warsaw"),
+        ("54.1522", "19.40884", "Elbląg", "PL", "Europe/Warsaw"),
+        ("52.54682", "19.70638", "Płock", "PL", "Europe/Warsaw"),
+        ("50.77141", "16.28432", "Wałbrzych", "PL", "Europe/Warsaw"),
+        ("52.73679", "15.22878", "Gorzów Wielkopolski", "PL", "Europe/Warsaw"),
+        ("52.64817", "19.0678", "Włocławek", "PL", "Europe/Warsaw"),
+        ("51.93548", "15.50643", "Zielona Góra", "PL", "Europe/Warsaw"),
+        ("50.01381", "20.98698", "Tarnów", "PL", "Europe/Warsaw"),
+        ("51.76109", "18.09102", "Kalisz", "PL", "Europe/Warsaw"),
+        ("54.19438", "16.17222", "Koszalin", "PL", "Europe/Warsaw"),
+        ("51.21006", "16.1619", "Legnica", "PL", "Europe/Warsaw"),
+        ("53.48411", "18.75366", "Grudziądz", "PL", "Europe/Warsaw"),
+        ("54.46405", "17.02872", "Słupsk", "PL", "Europe/Warsaw"),
     )
diff --git a/faker/providers/person/yo_NG/__init__.py b/faker/providers/person/yo_NG/__init__.py
new file mode 100644
index 00000000..db857302
--- /dev/null
+++ b/faker/providers/person/yo_NG/__init__.py
@@ -0,0 +1,340 @@
+from .. import Provider as PersonProvider
+
+
+class Provider(PersonProvider):
+    """
+    A Faker provider for generating fake Zulu names in South Africa.
+    """
+
+    formats = (
+        "{{first_name_male}} {{last_name_male}}",
+        "{{first_name_male}} {{last_name_male}}",
+        "{{first_name_male}} {{last_name_male}}",
+        "{{first_name_male}} {{last_name_male}}",
+        "{{first_name_male}} {{last_name_male}} {{last_name_male}}",
+        "{{first_name_female}} {{last_name_female}}",
+        "{{first_name_female}} {{last_name_female}}",
+        "{{first_name_female}} {{last_name_female}}",
+        "{{first_name_female}} {{last_name_female}}",
+        "{{first_name_female}} {{last_name_female}} {{last_name_female}}",
+        "{{prefix_male}} {{first_name_male}} {{last_name_male}}",
+        "{{prefix_female}} {{first_name_female}} {{last_name_female}}",
+        "{{prefix_male}} {{first_name_male}} {{last_name_male}}",
+        "{{prefix_female}} {{first_name_female}} {{last_name_female}}",
+    )
+
+    # first names sourced from:
+    # 1. https://github.com/faker-js/faker/blob/next/src/locales/yo_NG/person/last_name.ts
+    # 2. https://github.com/faker-js/faker/blob/next/src/locales/yo_NG/person/male_first_name.ts
+
+    first_names_male = (
+        "Abayomi",
+        "Abiodun",
+        "Abiona",
+        "Adebiyi",
+        "Adebowale",
+        "Adedayo",
+        "Adedeji",
+        "Adekitan",
+        "Adekola",
+        "Adekunle",
+        "Adeleke",
+        "Adeniyi",
+        "Adeolu",
+        "Adeoti",
+        "Aderopo",
+        "Adeshina",
+        "Adesoji",
+        "Adetayo",
+        "Adeyi",
+        "Adigun",
+        "Afolarin",
+        "Ajala",
+        "Ajani",
+        "Akanmu",
+        "Akinkunmi",
+        "Akinlabi",
+        "Akinwale",
+        "Alade",
+        "Alamu",
+        "Anjolaoluwa",
+        "Ayinde",
+        "Ayodeji",
+        "Ayodele",
+        "Babasola",
+        "Babatunji",
+        "Babawale",
+        "Damife",
+        "Demilade",
+        "Durodola",
+        "Ekundayo",
+        "Esupofo",
+        "Folu",
+        "Gbadebo",
+        "Gbolahan",
+        "Gbowoade",
+        "Ibidapo",
+        "Ige",
+        "Ikeoluwa",
+        "Inioluwa",
+        "Iseoluwa",
+        "Ishola",
+        "Juwon",
+        "Keji",
+        "Kolawole",
+        "Korede",
+        "Leke",
+        "Lere",
+        "Niyilolawa",
+        "Oba",
+        "ObaniJesu",
+        "Ogooluwa",
+        "Oke",
+        "Oladare",
+        "Oladimeji",
+        "Olakunle",
+        "Olanrewaju",
+        "Olansile",
+        "Olumorotimi",
+        "Oluwafemi",
+        "Oluwagbemiga",
+        "Oluwamumibori",
+        "Oluwamuyiwa",
+        "Oluwasanmi",
+        "Oluwasegun",
+        "Oluwole",
+        "Omobobola",
+        "Omotayo",
+        "Osunleke",
+        "Seye",
+        "Shekoni",
+        "Sijuade",
+        "Tade",
+        "Temidayo",
+        "Toki",
+        "Tokunbo",
+        "Tomori",
+    )
+    first_names_female = (
+        "Aanuoluwapo",
+        "Abebi",
+        "Abeni",
+        "Abosede",
+        "Adebukola",
+        "Adenike",
+        "Adepeju",
+        "Adesewa",
+        "Adesua",
+        "Adetoke",
+        "Adetoun",
+        "Adunni",
+        "Ajoke",
+        "Amoke",
+        "Amope",
+        "Arike",
+        "Arinola",
+        "Asake",
+        "Atinuke",
+        "Awero",
+        "Ayinke",
+        "Ayoka",
+        "Bolatito",
+        "Boluwatife",
+        "Bunmi",
+        "Doyinsola",
+        "Eniola",
+        "Ewatomi",
+        "Fadekemi",
+        "Faderera",
+        "Fehintola",
+        "Fibikemi",
+        "Fikayomi",
+        "Folashade",
+        "Ibironke",
+        "Iretioluwa",
+        "Iyabode",
+        "Iyadunni",
+        "Kikelomo",
+        "Modupe",
+        "Mofifoluwa",
+        "Mojisola",
+        "Mojisoluwa",
+        "Moradeke",
+        "Morayo",
+        "Morenike",
+        "Morolake",
+        "Mosinmileoluwa",
+        "Mosunmola",
+        "Motunrayo",
+        "Moyosore",
+        "Ninioluwa",
+        "Olajumoke",
+        "Olasunmbo",
+        "Ololade",
+        "Olufunke",
+        "Olufunmilayo",
+        "Oluwakemi",
+        "Omobolanle",
+        "Omodunni",
+        "Omolabake",
+        "Omolara",
+        "Omosalewa",
+        "Omotara",
+        "Omotola",
+        "Omotoun",
+        "Omowumi",
+        "Oreofe",
+        "Oyenike",
+        "Oyindasola",
+        "Radeke",
+        "Ronke",
+        "Segilola",
+        "Similoluwa",
+        "Simisola",
+        "Sowande",
+        "Subomi",
+        "Titilayo",
+        "Tolulope",
+        "Toluwanimi",
+        "Wuraola",
+        "Yejide",
+        "Yetunde",
+        "Yewande",
+    )
+
+    first_names = first_names_male + first_names_female
+
+    # last names sourced from :
+    # 1. https://github.com/faker-js/faker/blob/next/src/locales/yo_NG/person/last_name.ts
+    last_names_male = (
+        "Adebisi",
+        "Adegbite",
+        "Adegoke",
+        "Adekunle",
+        "Adelakun",
+        "Adeleke",
+        "Adelusi",
+        "Ademiluyi",
+        "Aderibigbe",
+        "Aderogba",
+        "Adesiyan",
+        "Adeyemo",
+        "Adisa",
+        "Afolabi",
+        "Afolayan",
+        "Afonja",
+        "Ajao",
+        "Ajayi",
+        "Ajewole",
+        "Akinrinola",
+        "Alabi",
+        "Aloba",
+        "Awodiran",
+        "Awolowo",
+        "Ayandokun",
+        "Ayoola",
+        "Babtunde",
+        "Bakare",
+        "Balogun",
+        "Bamidele",
+        "Bamiloye",
+        "Edun",
+        "Fadipe",
+        "Fagunwa",
+        "Fajimi",
+        "Falabi",
+        "Faleti",
+        "Faloye",
+        "Fasasi",
+        "Ibikunle",
+        "Ilori",
+        "Ilupeju",
+        "Iyanda",
+        "Jaiyeola",
+        "Kolade",
+        "Kosoko",
+        "Koya",
+        "Makinde",
+        "Makinwa",
+        "Morawo",
+        "Ninalowo",
+        "Odetola",
+        "Odunsi",
+        "Ogindan",
+        "Oginni",
+        "Ogulana",
+        "Ogunbamigbe",
+        "Ogunbiyi",
+        "Ogunbo",
+        "Ogunde",
+        "Ogunwobi",
+        "Ogunyeye",
+        "Ojo",
+        "Ojua",
+        "Olabode",
+        "Oladipupo",
+        "Olaiya",
+        "Olasupo",
+        "Olowokeere",
+        "Oloyede",
+        "Olubode",
+        "Olugbayila",
+        "Olujimi",
+        "Olukotun",
+        "Olukunga",
+        "Olusanya",
+        "Oluwagbemi",
+        "Omidina",
+        "Omojola",
+        "Omotoso",
+        "Oparinde",
+        "Oshin",
+        "Osuntokun",
+        "Owokoniran",
+        "Owolabi",
+        "Owoyemi",
+        "Oyadiran",
+        "Oyaifo",
+        "Oyeniyi",
+        "Oyetoro",
+        "Oyeyemi",
+        "Oyinlola",
+        "Paimo",
+        "Salako",
+        "Salami",
+        "Shekoni",
+        "Sobowale",
+        "Soyinka",
+    )
+
+    # last names are not sex dependant
+    last_names_female = last_names_male
+    last_names = last_names_male + last_names_female
+
+    prefixes_female = (
+        "Mrs.",
+        "Ms.",
+        "Dr.",
+        "Alhaja",
+        "Mama",
+        "Iya",
+        "Madam",
+        "Chief",
+        "Lady",
+        "Erelu",
+        "Olori",
+        "Princess",
+    )
+
+    prefixes_male = (
+        "Mr.",
+        "Dr.",
+        "Alhaji",
+        "Baba",
+        "Ogbeni",
+        "Oloye",
+        "Chief",
+        "Prince",
+        "Oba",
+        "Kabiyesi",
+    )
diff --git a/faker/proxy.pyi b/faker/proxy.pyi
index 679c9ca1..2457427b 100644
--- a/faker/proxy.pyi
+++ b/faker/proxy.pyi
@@ -1,32 +1,16 @@
-import datetime
 
 from collections import OrderedDict
-from decimal import Decimal
-from enum import Enum
 from json import encoder
-from typing import (
-    Any,
-    Callable,
-    Collection,
-    Dict,
-    Iterable,
-    Iterator,
-    List,
-    Literal,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
+from typing import Literal, Callable, Iterator, Dict, Type, Set, Any, Optional, Sequence, Collection, Union, List, Iterable, Tuple, TypeVar
 from uuid import UUID
-
+from enum import Enum
+from faker.typing import *
 from faker.generator import Generator
 from faker.providers import T
+import datetime
+from decimal import Decimal
 from faker.providers.python import TEnum
-from faker.typing import *
+from types import faker.generator.Generator | None, list[str] | None
 
 class Faker:
     def address(self) -> str:
@@ -38,16 +22,16 @@ class Faker:
     def bothify(self, text: str = ..., letters: str = ...) -> str:
         """
         Generate a string with each placeholder in ``text`` replaced according to the following rules:
-
+        
         - Number signs ('#') are replaced with a random digit (0 to 9).
         - Question marks ('?') are replaced with a random character from ``letters``.
-
+        
         By default, ``letters`` contains all ASCII letters, uppercase and lowercase.
-
+        
         Under the hood, this method uses :meth:`numerify() <faker.providers.BaseProvider.numerify>` and
         and :meth:`lexify() <faker.providers.BaseProvider.lexify>` to generate random values for number
         signs and question marks respectively.
-
+        
         :sample: letters='ABCDE'
         :sample: text='Product Number: ????-########'
         :sample: text='Product Number: ????-########', letters='ABCDE'
@@ -77,10 +61,10 @@ class Faker:
         """
         Generate a string with each circumflex ('^') in ``text``
         replaced with a random hexadecimal character.
-
+        
         By default, ``upper`` is set to False. If set to ``True``, output
         will be formatted using uppercase hexadecimal characters.
-
+        
         :sample: text='MAC Address: ^^:^^:^^:^^:^^:^^'
         :sample: text='MAC Address: ^^:^^:^^:^^:^^:^^', upper=True
         """
@@ -94,9 +78,9 @@ class Faker:
         """
         Generate a string with each question mark ('?') in ``text``
         replaced with a random character from ``letters``.
-
+        
         By default, ``letters`` contains all ASCII letters, uppercase and lowercase.
-
+        
         :sample: text='Random Identifier: ??????????'
         :sample: text='Random Identifier: ??????????', letters='ABCDE'
         """
@@ -130,19 +114,19 @@ class Faker:
         """
         Generate a string with each placeholder in ``text`` replaced according
         to the following rules:
-
+        
         - Number signs ('#') are replaced with a random digit (0 to 9).
         - Percent signs ('%') are replaced with a random non-zero digit (1 to 9).
         - Dollar signs ('$') are replaced with a random digit above two (2 to 9).
         - Exclamation marks ('!') are replaced with a random digit or an empty string.
         - At symbols ('@') are replaced with a random non-zero digit or an empty string.
-
+        
         Under the hood, this method uses :meth:`random_digit() <faker.providers.BaseProvider.random_digit>`,
         :meth:`random_digit_not_null() <faker.providers.BaseProvider.random_digit_not_null>`,
         :meth:`random_digit_or_empty() <faker.providers.BaseProvider.random_digit_or_empty>`,
         and :meth:`random_digit_not_null_or_empty() <faker.providers.BaseProvider.random_digit_not_null_or_empty>`
         to generate the random values.
-
+        
         :sample: text='Intel Core i%-%%##K vs AMD Ryzen % %%##X'
         :sample: text='!!! !!@ !@! !@@ @!! @!@ @@! @@@'
         """
@@ -158,20 +142,18 @@ class Faker:
     def postcode_in_state(self, state_abbr: Optional[str] = ...) -> str:
         """
         :returns: A random postcode within the provided state abbreviation
-
+        
         :param state_abbr: A state abbreviation
         """
         ...
-    def random_choices(
-        self, elements: Union[Collection[str], Collection[T], OrderedDict[T, float]] = ..., length: Optional[int] = ...
-    ) -> Sequence[T]:
+    def random_choices(self, elements: Union[Collection[str], Collection[T], OrderedDict[T, float]] = ..., length: Optional[int] = ...) -> Sequence[T]:
         """
         Generate a list of objects randomly sampled from ``elements`` with replacement.
-
+        
         For information on the ``elements`` and ``length`` arguments, please refer to
         :meth:`random_elements() <faker.providers.BaseProvider.random_elements>` which
         is used under the hood with the ``unique`` argument explicitly set to ``False``.
-
+        
         :sample: elements=('a', 'b', 'c', 'd')
         :sample: elements=('a', 'b', 'c', 'd'), length=10
         :sample: elements=OrderedDict([
@@ -206,7 +188,7 @@ class Faker:
     def random_digit_not_null_or_empty(self) -> Union[int, str]:
         """
         Generate a random non-zero digit (1 to 9) or an empty string.
-
+        
         This method will return an empty string 50% of the time,
         and each digit has a 1/18 chance of being generated.
         """
@@ -214,7 +196,7 @@ class Faker:
     def random_digit_or_empty(self) -> Union[int, str]:
         """
         Generate a random digit (0 to 9) or an empty string.
-
+        
         This method will return an empty string 50% of the time,
         and each digit has a 1/20 chance of being generated.
         """
@@ -222,12 +204,12 @@ class Faker:
     def random_element(self, elements: Union[Collection[str], Collection[T], OrderedDict[T, float]] = ...) -> T:
         """
         Generate a randomly sampled object from ``elements``.
-
+        
         For information on the ``elements`` argument, please refer to
         :meth:`random_elements() <faker.providers.BaseProvider.random_elements>` which
         is used under the hood with the ``unique`` argument set to ``False`` and the
         ``length`` argument set to ``1``.
-
+        
         :sample: elements=('a', 'b', 'c', 'd')
         :sample size=10: elements=OrderedDict([
                      ("a", 0.45),
@@ -237,32 +219,26 @@ class Faker:
                  ])
         """
         ...
-    def random_elements(
-        self,
-        elements: Union[Collection[str], Collection[T], OrderedDict[T, float]] = ...,
-        length: Optional[int] = ...,
-        unique: bool = ...,
-        use_weighting: Optional[bool] = ...,
-    ) -> Sequence[T]:
+    def random_elements(self, elements: Union[Collection[str], Collection[T], OrderedDict[T, float]] = ..., length: Optional[int] = ..., unique: bool = ..., use_weighting: Optional[bool] = ...) -> Sequence[T]:
         """
         Generate a list of randomly sampled objects from ``elements``.
-
+        
         Set ``unique`` to ``False`` for random sampling with replacement, and set ``unique`` to
         ``True`` for random sampling without replacement.
-
+        
         If ``length`` is set to ``None`` or is omitted, ``length`` will be set to a random
         integer from 1 to the size of ``elements``.
-
+        
         The value of ``length`` cannot be greater than the number of objects
         in ``elements`` if ``unique`` is set to ``True``.
-
+        
         The value of ``elements`` can be any sequence type (``list``, ``tuple``, ``set``,
         ``string``, etc) or an ``OrderedDict`` type. If it is the latter, the keys will be
         used as the objects for sampling, and the values will be used as weighted probabilities
         if ``unique`` is set to ``False``. For example:
-
+        
         .. code-block:: python
-
+        
             # Random sampling with replacement
             fake.random_elements(
                 elements=OrderedDict([
@@ -272,7 +248,7 @@ class Faker:
                     ("variable_4": 0.1),        # Generates "variable_4" 10% of the time
                 ]), unique=False
             )
-
+        
             # Random sampling without replacement (defaults to uniform distribution)
             fake.random_elements(
                 elements=OrderedDict([
@@ -282,7 +258,7 @@ class Faker:
                     ("variable_4": 0.1),
                 ]), unique=True
             )
-
+        
         :sample: elements=('a', 'b', 'c', 'd'), unique=False
         :sample: elements=('a', 'b', 'c', 'd'), unique=True
         :sample: elements=('a', 'b', 'c', 'd'), length=10, unique=False
@@ -305,10 +281,10 @@ class Faker:
         """
         Generate a random integer between two integers ``min`` and ``max`` inclusive
         while observing the provided ``step`` value.
-
+        
         This method is functionally equivalent to randomly sampling an integer
         from the sequence ``range(min, max + 1, step)``.
-
+        
         :sample: min=0, max=15
         :sample: min=0, max=15, step=3
         """
@@ -321,7 +297,7 @@ class Faker:
     def random_letters(self, length: int = ...) -> Sequence[str]:
         """
         Generate a list of random ASCII letters (a-z and A-Z) of the specified ``length``.
-
+        
         :sample: length=10
         """
         ...
@@ -333,14 +309,14 @@ class Faker:
     def random_number(self, digits: Optional[int] = ..., fix_len: bool = ...) -> int:
         """
         Generate a random integer according to the following rules:
-
+        
         - If ``digits`` is ``None`` (default), its value will be set to a random
           integer from 1 to 9.
         - If ``fix_len`` is ``False`` (default), all integers that do not exceed
           the number of ``digits`` can be generated.
         - If ``fix_len`` is ``True``, only integers with the exact number of
           ``digits`` can be generated.
-
+        
         :sample: fix_len=False
         :sample: fix_len=True
         :sample: digits=3
@@ -348,16 +324,14 @@ class Faker:
         :sample: digits=3, fix_len=True
         """
         ...
-    def random_sample(
-        self, elements: Union[Collection[str], Collection[T], OrderedDict[T, float]] = ..., length: Optional[int] = ...
-    ) -> Sequence[T]:
+    def random_sample(self, elements: Union[Collection[str], Collection[T], OrderedDict[T, float]] = ..., length: Optional[int] = ...) -> Sequence[T]:
         """
         Generate a list of objects randomly sampled from ``elements`` without replacement.
-
+        
         For information on the ``elements`` and ``length`` arguments, please refer to
         :meth:`random_elements() <faker.providers.BaseProvider.random_elements>` which
         is used under the hood with the ``unique`` argument explicitly set to ``True``.
-
+        
         :sample: elements=('a', 'b', 'c', 'd', 'e', 'f')
         :sample: elements=('a', 'b', 'c', 'd', 'e', 'f'), length=3
         """
@@ -367,12 +341,10 @@ class Faker:
         Generate a random uppercase ASCII letter (A-Z).
         """
         ...
-    def randomize_nb_elements(
-        self, number: int = ..., le: bool = ..., ge: bool = ..., min: Optional[int] = ..., max: Optional[int] = ...
-    ) -> int:
+    def randomize_nb_elements(self, number: int = ..., le: bool = ..., ge: bool = ..., min: Optional[int] = ..., max: Optional[int] = ...) -> int:
         """
         Generate a random integer near ``number`` according to the following rules:
-
+        
         - If ``le`` is ``False`` (default), allow generation up to 140% of ``number``.
           If ``True``, upper bound generation is capped at 100%.
         - If ``ge`` is ``False`` (default), allow generation down to 60% of ``number``.
@@ -383,7 +355,7 @@ class Faker:
           ``max`` will be clamped at ``max``.
         - If both ``le`` and ``ge`` are ``True``, the value of ``number`` will automatically
           be returned, regardless of the values supplied for ``min`` and ``max``.
-
+        
         :sample: number=100
         :sample: number=100, ge=True
         :sample: number=100, ge=True, min=120
@@ -397,10 +369,10 @@ class Faker:
     def state_abbr(self, include_territories: bool = ..., include_freely_associated_states: bool = ...) -> str:
         """
         :returns: A random two-letter USPS postal code
-
+        
         By default, the resulting code may abbreviate any of the fifty states,
         five US territories, or three freely-associating sovereign states.
-
+        
         :param include_territories: If True, territories will be included.
             If False, US territories will be excluded.
         :param include_freely_associated_states: If True, freely-associated states will be included.
@@ -458,7 +430,7 @@ class Faker:
     def swift(self, length: Optional[int] = ..., primary: bool = ..., use_dataset: bool = ...) -> str:
         """
         Generate a SWIFT code.
-
+        
         SWIFT codes, reading from left to right, are composed of a 4 alphabet
         character bank code, a 2 alphabet character country code, a 2
         alphanumeric location code, and an optional 3 alphanumeric branch code.
@@ -466,13 +438,13 @@ class Faker:
         ``length`` can only be ``None`` or the integers ``8`` or ``11``. If the
         value is ``None``, then a value of ``8`` or ``11`` will randomly be
         assigned.
-
+        
         Because all 8-digit SWIFT codes already refer to the primary branch or
         office, the ``primary`` argument only has an effect if the value of
         ``length`` is ``11``. If ``primary`` is ``True`` and ``length`` is
         ``11``, the 11-digit SWIFT codes generated will always end in ``'XXX'``
         to denote that they belong to primary branches/offices.
-
+        
         For extra authenticity, localized providers may opt to include SWIFT
         bank codes, location codes, and branch codes used in their respective
         locales. If ``use_dataset`` is ``True``, this method will generate SWIFT
@@ -480,7 +452,7 @@ class Faker:
         were not included, then it will behave as if ``use_dataset`` were
         ``False``, and in that mode, all those codes will just be randomly
         generated as per the specification.
-
+        
         :sample:
         :sample: length=8
         :sample: length=8, use_dataset=True
@@ -493,12 +465,12 @@ class Faker:
     def swift11(self, primary: bool = ..., use_dataset: bool = ...) -> str:
         """
         Generate an 11-digit SWIFT code.
-
+        
         This method uses |swift| under the hood with the ``length`` argument set
         to ``11``. If ``primary`` is set to ``True``, the SWIFT code will always
         end with ``'XXX'``. All 11-digit SWIFT codes use this convention to
         refer to the primary branch/office.
-
+        
         :sample:
         :sample: use_dataset=True
         """
@@ -506,11 +478,11 @@ class Faker:
     def swift8(self, use_dataset: bool = ...) -> str:
         """
         Generate an 8-digit SWIFT code.
-
+        
         This method uses |swift| under the hood with the ``length`` argument set
         to ``8`` and with the ``primary`` argument omitted. All 8-digit SWIFT
         codes already refer to the primary branch/office.
-
+        
         :sample:
         :sample: use_dataset=True
         """
@@ -518,49 +490,45 @@ class Faker:
     def ean(self, length: int = ..., prefixes: Tuple[Union[int, str, Tuple[Union[int, str], ...]], ...] = ...) -> str:
         """
         Generate an EAN barcode of the specified ``length``.
-
+        
         The value of ``length`` can only be ``8`` or ``13`` (default) which will
         create an EAN-8 or an EAN-13 barcode respectively.
-
+        
         If a value for ``prefixes`` is specified, the result will begin with one
         of the sequences in ``prefixes``.
-
+        
         :sample: length=13
         :sample: length=8
         :sample: prefixes=('00',)
         :sample: prefixes=('45', '49')
         """
         ...
-    def ean13(
-        self,
-        prefixes: Tuple[Union[int, str, Tuple[Union[int, str], ...]], ...] = ...,
-        leading_zero: Optional[bool] = ...,
-    ) -> str:
+    def ean13(self, prefixes: Tuple[Union[int, str, Tuple[Union[int, str], ...]], ...] = ..., leading_zero: Optional[bool] = ...) -> str:
         """
         Generate an EAN-13 barcode.
-
+        
         If ``leading_zero`` is ``True``, the leftmost digit of the barcode will
         be set to ``0``. If ``False``, the leftmost digit cannot be ``0``. If
         ``None`` (default), the leftmost digit can be any digit.
-
+        
         If a value for ``prefixes`` is specified, the result will begin with one
         of the sequences in ``prefixes`` and will ignore ``leading_zero``.
-
+        
         This method uses the standard barcode provider's |ean13| under the
         hood with the ``prefixes`` argument set to the correct value to attain
         the behavior described above.
-
+        
         .. note::
            EAN-13 barcode that starts with a zero can be converted to UPC-A
            by dropping the leading zero. This may cause problems with readers
            that treat all of these code as UPC-A codes and drop the first digit
            when reading it.
-
+        
            You can set the argument ``prefixes`` ( or ``leading_zero`` for
            convenience) explicitly to avoid or to force the generated barcode to
            start with a zero. You can also generate actual UPC-A barcode with
            |EnUsBarcodeProvider.upc_a|.
-
+        
         :sample:
         :sample: leading_zero=False
         :sample: leading_zero=True
@@ -571,13 +539,13 @@ class Faker:
     def ean8(self, prefixes: Tuple[Union[int, str, Tuple[Union[int, str], ...]], ...] = ...) -> str:
         """
         Generate an EAN-8 barcode.
-
+        
         This method uses |ean| under the hood with the ``length`` argument
         explicitly set to ``8``.
-
+        
         If a value for ``prefixes`` is specified, the result will begin with one
         of the sequences in ``prefixes``.
-
+        
         :sample:
         :sample: prefixes=('00',)
         :sample: prefixes=('45', '49')
@@ -586,14 +554,14 @@ class Faker:
     def localized_ean(self, length: int = ...) -> str:
         """
         Generate a localized EAN barcode of the specified ``length``.
-
+        
         The value of ``length`` can only be ``8`` or ``13`` (default) which will
         create an EAN-8 or an EAN-13 barcode respectively.
-
+        
         This method uses the standard barcode provider's |ean| under the hood
         with the ``prefixes`` argument explicitly set to ``local_prefixes`` of
         a localized barcode provider implementation.
-
+        
         :sample:
         :sample: length=13
         :sample: length=8
@@ -602,7 +570,7 @@ class Faker:
     def localized_ean13(self) -> str:
         """
         Generate a localized EAN-13 barcode.
-
+        
         This method uses |localized_ean| under the hood with the ``length``
         argument explicitly set to ``13``.
         """
@@ -610,33 +578,31 @@ class Faker:
     def localized_ean8(self) -> str:
         """
         Generate a localized EAN-8 barcode.
-
+        
         This method uses |localized_ean| under the hood with the ``length``
         argument explicitly set to ``8``.
         """
         ...
-    def upc_a(
-        self, upc_ae_mode: bool = ..., base: Optional[str] = ..., number_system_digit: Optional[int] = ...
-    ) -> str:
+    def upc_a(self, upc_ae_mode: bool = ..., base: Optional[str] = ..., number_system_digit: Optional[int] = ...) -> str:
         """
         Generate a 12-digit UPC-A barcode.
-
+        
         The value of ``upc_ae_mode`` controls how barcodes will be generated. If
         ``False`` (default), barcodes are not guaranteed to have a UPC-E
         equivalent. In this mode, the method uses |EnUsBarcodeProvider.ean13|
         under the hood, and the values of ``base`` and ``number_system_digit``
         will be ignored.
-
+        
         If ``upc_ae_mode`` is ``True``, the resulting barcodes are guaranteed to
         have a UPC-E equivalent, and the values of ``base`` and
         ``number_system_digit`` will be used to control what is generated.
-
+        
         Under this mode, ``base`` is expected to have a 6-digit string value. If
         any other value is supplied, a random 6-digit string will be used
         instead. As for ``number_system_digit``, the expected value is a ``0``
         or a ``1``. If any other value is provided, this method will randomly
         choose from the two.
-
+        
         .. important::
            When ``upc_ae_mode`` is enabled, you might encounter instances where
            different values of ``base`` (e.g. ``'120003'`` and ``'120004'``)
@@ -644,7 +610,7 @@ class Faker:
            within the whole conversion process. To learn more about this and
            what ``base`` and ``number_system_digit`` actually represent, please
            refer to |EnUsBarcodeProvider.upc_e|.
-
+        
         :sample:
         :sample: upc_ae_mode=True, number_system_digit=0
         :sample: upc_ae_mode=True, number_system_digit=1
@@ -656,7 +622,7 @@ class Faker:
     def upc_e(self, base: Optional[str] = ..., number_system_digit: Optional[int] = ..., safe_mode: bool = ...) -> str:
         """
         Generate an 8-digit UPC-E barcode.
-
+        
         UPC-E barcodes can be expressed in 6, 7, or 8-digit formats, but this
         method uses the 8 digit format, since it is trivial to convert to the
         other two formats. The first digit (starting from the left) is
@@ -664,7 +630,7 @@ class Faker:
         ``1``. The last digit is the check digit that is inherited from the
         UPC-E barcode's UPC-A equivalent. The middle six digits are collectively
         referred to as the ``base`` (for a lack of a better term).
-
+        
         On that note, this method uses ``base`` and ``number_system_digit`` to
         first generate a UPC-A barcode for the check digit, and what happens
         next depends on the value of ``safe_mode``. The argument ``safe_mode``
@@ -674,20 +640,20 @@ class Faker:
         ``abc00000000d``, but that UPC-A value will only convert to ``abc0000d``
         because of (a) how UPC-E is just a zero-suppressed version of UPC-A and
         (b) the rules around the conversion.
-
+        
         If ``safe_mode`` is ``True`` (default), this method performs another set
         of conversions to guarantee that the UPC-E barcodes generated can be
         converted to UPC-A, and that UPC-A barcode can be converted back to the
         original UPC-E barcode. Using the example above, even if the bases
         ``120003`` or ``120004`` are used, the resulting UPC-E barcode will
         always use the base ``120000``.
-
+        
         If ``safe_mode`` is ``False``, then the ``number_system_digit``,
         ``base``, and the computed check digit will just be concatenated
         together to produce the UPC-E barcode, and attempting to convert the
         barcode to UPC-A and back again to UPC-E will exhibit the behavior
         described above.
-
+        
         :sample:
         :sample: base='123456'
         :sample: base='123456', number_system_digit=0
@@ -700,20 +666,15 @@ class Faker:
         :sample: base='120004', number_system_digit=0, safe_mode=False
         """
         ...
-    def color(
-        self,
-        hue: Union[str, float, int, Sequence[int], None] = ...,
-        luminosity: Optional[str] = ...,
-        color_format: str = ...,
-    ) -> str:
+    def color(self, hue: Union[str, float, int, Sequence[int], None] = ..., luminosity: Optional[str] = ..., color_format: str = ...) -> str:
         """
         Generate a color in a human-friendly way.
-
+        
         Under the hood, this method first creates a color represented in the HSV
         color model and then converts it to the desired ``color_format``. The
         argument ``hue`` controls the H value according to the following
         rules:
-
+        
         - If the value is a number from ``0`` to ``360``, it will serve as the H
           value of the generated color.
         - If the value is a tuple/list of 2 numbers from 0 to 360, the color's H
@@ -722,18 +683,18 @@ class Faker:
           selected from the H range corresponding to the supplied string. Valid
           values are ``'monochrome'``, ``'red'``, ``'orange'``, ``'yellow'``,
           ``'green'``, ``'blue'``, ``'purple'``, and ``'pink'``.
-
+        
         The argument ``luminosity`` influences both S and V values and is
         partially affected by ``hue`` as well. The finer details of this
         relationship are somewhat involved, so please refer to the source code
         instead if you wish to dig deeper. To keep the interface simple, this
         argument either can be omitted or can accept the following string
         values:``'bright'``, ``'dark'``, ``'light'``, or ``'random'``.
-
+        
         The argument ``color_format`` controls in which color model the color is
         represented. Valid values are ``'hsv'``, ``'hsl'``, ``'rgb'``, or
         ``'hex'`` (default).
-
+        
         :sample: hue='red'
         :sample: luminosity='light'
         :sample: hue=(100, 200), color_format='rgb'
@@ -742,16 +703,12 @@ class Faker:
         :sample: hue=(300, 20), luminosity='random', color_format='hsl'
         """
         ...
-    def color_hsl(
-        self, hue: Union[str, float, int, Sequence[int], None] = ..., luminosity: Optional[str] = ...
-    ) -> Tuple[int, int, int]:
+    def color_hsl(self, hue: Union[str, float, int, Sequence[int], None] = ..., luminosity: Optional[str] = ...) -> Tuple[int, int, int]:
         """
         Generate a HSL color tuple in a human-friendly way.
         """
         ...
-    def color_hsv(
-        self, hue: Union[str, float, int, Sequence[int], None] = ..., luminosity: Optional[str] = ...
-    ) -> Tuple[int, int, int]:
+    def color_hsv(self, hue: Union[str, float, int, Sequence[int], None] = ..., luminosity: Optional[str] = ...) -> Tuple[int, int, int]:
         """
         Generate a HSV color tuple in a human-friendly way.
         """
@@ -761,16 +718,12 @@ class Faker:
         Generate a color name.
         """
         ...
-    def color_rgb(
-        self, hue: Union[str, float, int, Sequence[int], None] = ..., luminosity: Optional[str] = ...
-    ) -> Tuple[int, int, int]:
+    def color_rgb(self, hue: Union[str, float, int, Sequence[int], None] = ..., luminosity: Optional[str] = ...) -> Tuple[int, int, int]:
         """
         Generate a RGB color tuple of integers in a human-friendly way.
         """
         ...
-    def color_rgb_float(
-        self, hue: Union[str, float, int, Sequence[int], None] = ..., luminosity: Optional[str] = ...
-    ) -> Tuple[float, float, float]:
+    def color_rgb_float(self, hue: Union[str, float, int, Sequence[int], None] = ..., luminosity: Optional[str] = ...) -> Tuple[float, float, float]:
         """
         Generate a RGB color tuple of floats in a human-friendly way.
         """
@@ -820,15 +773,10 @@ class Faker:
         :example: 'Ltd'
         """
         ...
-    def credit_card_expire(
-        self,
-        start: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-        end: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-        date_format: str = ...,
-    ) -> str:
+    def credit_card_expire(self, start: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ..., end: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ..., date_format: str = ...) -> str:
         """
         Generate a credit card expiry date.
-
+        
         This method uses |date_time_between| under the hood to generate the
         expiry date, so the ``start`` and ``end`` arguments work in the same way
         here as it would in that method. For the actual formatting of the expiry
@@ -874,43 +822,31 @@ class Faker:
         :example: 'XVII'
         """
         ...
-    def date(
-        self,
-        pattern: str = ...,
-        end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-    ) -> str:
+    def date(self, pattern: str = ..., end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...) -> str:
         """
         Get a date string between January 1, 1970 and now.
-
+        
         :param pattern: Format of the date (year-month-day by default)
         :example: '2008-11-27'
         :return: Date
         """
         ...
-    def date_between(
-        self,
-        start_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-        end_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-    ) -> datetime.date:
+    def date_between(self, start_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ..., end_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...) -> datetime.date:
         """
         Get a Date object based on a random date between two given dates.
         Accepts date strings that can be recognized by strtotime().
-
+        
         :param start_date: Defaults to 30 years ago
         :param end_date: Defaults to "today"
         :example: Date('1999-02-02')
         :return: Date
         """
         ...
-    def date_between_dates(
-        self,
-        date_start: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-        date_end: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-    ) -> datetime.date:
+    def date_between_dates(self, date_start: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ..., date_end: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...) -> datetime.date:
         """
         Takes two Date objects and returns a random date between the two given dates.
         Accepts Date or datetime objects
-
+        
         :param date_start: Date
         :param date_end: Date
         :return: Date
@@ -919,22 +855,20 @@ class Faker:
     def date_object(self, end_datetime: Optional[datetime.datetime] = ...) -> datetime.date:
         """
         Get a date object between January 1, 1970 and now
-
+        
         :example: datetime.date(2016, 9, 20)
         """
         ...
-    def date_of_birth(
-        self, tzinfo: Optional[datetime.tzinfo] = ..., minimum_age: int = ..., maximum_age: int = ...
-    ) -> datetime.date:
+    def date_of_birth(self, tzinfo: Optional[datetime.tzinfo] = ..., minimum_age: int = ..., maximum_age: int = ...) -> datetime.date:
         """
         Generate a random date of birth represented as a Date object,
         constrained by optional miminimum_age and maximum_age
         parameters.
-
+        
         :param tzinfo: Defaults to None.
         :param minimum_age: Defaults to 0.
         :param maximum_age: Defaults to 115.
-
+        
         :example: Date('1979-02-02')
         :return: Date
         """
@@ -942,7 +876,7 @@ class Faker:
     def date_this_century(self, before_today: bool = ..., after_today: bool = ...) -> datetime.date:
         """
         Gets a Date object for the current century.
-
+        
         :param before_today: include days in current century before today
         :param after_today: include days in current century after today
         :example: Date('2012-04-04')
@@ -952,7 +886,7 @@ class Faker:
     def date_this_decade(self, before_today: bool = ..., after_today: bool = ...) -> datetime.date:
         """
         Gets a Date object for the decade year.
-
+        
         :param before_today: include days in current decade before today
         :param after_today: include days in current decade after today
         :example: Date('2012-04-04')
@@ -962,7 +896,7 @@ class Faker:
     def date_this_month(self, before_today: bool = ..., after_today: bool = ...) -> datetime.date:
         """
         Gets a Date object for the current month.
-
+        
         :param before_today: include days in current month before today
         :param after_today: include days in current month after today
         :example: dtdate('2012-04-04')
@@ -972,50 +906,36 @@ class Faker:
     def date_this_year(self, before_today: bool = ..., after_today: bool = ...) -> datetime.date:
         """
         Gets a Date object for the current year.
-
+        
         :param before_today: include days in current year before today
         :param after_today: include days in current year after today
         :example: Date('2012-04-04')
         :return: Date
         """
         ...
-    def date_time(
-        self,
-        tzinfo: Optional[datetime.tzinfo] = ...,
-        end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-    ) -> datetime.datetime:
+    def date_time(self, tzinfo: Optional[datetime.tzinfo] = ..., end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...) -> datetime.datetime:
         """
         Get a datetime object for a date between January 1, 1970 and now
-
+        
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
         :example: datetime('2005-08-16 20:39:21')
         :return: datetime
         """
         ...
-    def date_time_ad(
-        self,
-        tzinfo: Optional[datetime.tzinfo] = ...,
-        end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-        start_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-    ) -> datetime.datetime:
+    def date_time_ad(self, tzinfo: Optional[datetime.tzinfo] = ..., end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ..., start_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...) -> datetime.datetime:
         """
         Get a datetime object for a date between January 1, 001 and now
-
+        
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
         :example: datetime('1265-03-22 21:15:52')
         :return: datetime
         """
         ...
-    def date_time_between(
-        self,
-        start_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-        end_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-        tzinfo: Optional[datetime.tzinfo] = ...,
-    ) -> datetime.datetime:
+    def date_time_between(self, start_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ..., end_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ..., tzinfo: Optional[datetime.tzinfo] = ...) -> datetime.datetime:
         """
         Get a datetime object based on a random date between two given dates.
         Accepts date strings that can be recognized by strtotime().
-
+        
         :param start_date: Defaults to 30 years ago
         :param end_date: Defaults to "now"
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
@@ -1023,17 +943,12 @@ class Faker:
         :return: datetime
         """
         ...
-    def date_time_between_dates(
-        self,
-        datetime_start: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-        datetime_end: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-        tzinfo: Optional[datetime.tzinfo] = ...,
-    ) -> datetime.datetime:
+    def date_time_between_dates(self, datetime_start: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ..., datetime_end: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ..., tzinfo: Optional[datetime.tzinfo] = ...) -> datetime.datetime:
         """
         Takes two datetime objects and returns a random datetime between the two
         given datetimes.
         Accepts datetime objects.
-
+        
         :param datetime_start: datetime
         :param datetime_end: datetime
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
@@ -1041,12 +956,10 @@ class Faker:
         :return: datetime
         """
         ...
-    def date_time_this_century(
-        self, before_now: bool = ..., after_now: bool = ..., tzinfo: Optional[datetime.tzinfo] = ...
-    ) -> datetime.datetime:
+    def date_time_this_century(self, before_now: bool = ..., after_now: bool = ..., tzinfo: Optional[datetime.tzinfo] = ...) -> datetime.datetime:
         """
         Gets a datetime object for the current century.
-
+        
         :param before_now: include days in current century before today
         :param after_now: include days in current century after today
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
@@ -1054,12 +967,10 @@ class Faker:
         :return: datetime
         """
         ...
-    def date_time_this_decade(
-        self, before_now: bool = ..., after_now: bool = ..., tzinfo: Optional[datetime.tzinfo] = ...
-    ) -> datetime.datetime:
+    def date_time_this_decade(self, before_now: bool = ..., after_now: bool = ..., tzinfo: Optional[datetime.tzinfo] = ...) -> datetime.datetime:
         """
         Gets a datetime object for the decade year.
-
+        
         :param before_now: include days in current decade before today
         :param after_now: include days in current decade after today
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
@@ -1067,12 +978,10 @@ class Faker:
         :return: datetime
         """
         ...
-    def date_time_this_month(
-        self, before_now: bool = ..., after_now: bool = ..., tzinfo: Optional[datetime.tzinfo] = ...
-    ) -> datetime.datetime:
+    def date_time_this_month(self, before_now: bool = ..., after_now: bool = ..., tzinfo: Optional[datetime.tzinfo] = ...) -> datetime.datetime:
         """
         Gets a datetime object for the current month.
-
+        
         :param before_now: include days in current month before today
         :param after_now: include days in current month after today
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
@@ -1080,12 +989,10 @@ class Faker:
         :return: datetime
         """
         ...
-    def date_time_this_year(
-        self, before_now: bool = ..., after_now: bool = ..., tzinfo: Optional[datetime.tzinfo] = ...
-    ) -> datetime.datetime:
+    def date_time_this_year(self, before_now: bool = ..., after_now: bool = ..., tzinfo: Optional[datetime.tzinfo] = ...) -> datetime.datetime:
         """
         Gets a datetime object for the current year.
-
+        
         :param before_now: include days in current year before today
         :param after_now: include days in current year after today
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
@@ -1095,48 +1002,34 @@ class Faker:
         ...
     def day_of_month(self) -> str: ...
     def day_of_week(self) -> str: ...
-    def future_date(
-        self,
-        end_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-        tzinfo: Optional[datetime.tzinfo] = ...,
-    ) -> datetime.date:
+    def future_date(self, end_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ..., tzinfo: Optional[datetime.tzinfo] = ...) -> datetime.date:
         """
         Get a Date object based on a random date between 1 day from now and a
         given date.
         Accepts date strings that can be recognized by strtotime().
-
+        
         :param end_date: Defaults to "+30d"
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
         :example: dtdate('2030-01-01')
         :return: dtdate
         """
         ...
-    def future_datetime(
-        self,
-        end_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-        tzinfo: Optional[datetime.tzinfo] = ...,
-    ) -> datetime.datetime:
+    def future_datetime(self, end_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ..., tzinfo: Optional[datetime.tzinfo] = ...) -> datetime.datetime:
         """
         Get a datetime object based on a random date between 1 second form now
         and a given date.
         Accepts date strings that can be recognized by strtotime().
-
+        
         :param end_date: Defaults to "+30d"
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
         :example: datetime('1999-02-02 11:42:52')
         :return: datetime
         """
         ...
-    def iso8601(
-        self,
-        tzinfo: Optional[datetime.tzinfo] = ...,
-        end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-        sep: str = ...,
-        timespec: str = ...,
-    ) -> str:
+    def iso8601(self, tzinfo: Optional[datetime.tzinfo] = ..., end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ..., sep: str = ..., timespec: str = ...) -> str:
         """
         Get a timestamp in ISO 8601 format (or one of its profiles).
-
+        
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
         :param sep: separator between date and time, defaults to 'T'
         :param timespec: format specifier for the time part, defaults to 'auto' - see datetime.isoformat() documentation
@@ -1145,32 +1038,24 @@ class Faker:
         ...
     def month(self) -> str: ...
     def month_name(self) -> str: ...
-    def past_date(
-        self,
-        start_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-        tzinfo: Optional[datetime.tzinfo] = ...,
-    ) -> datetime.date:
+    def past_date(self, start_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ..., tzinfo: Optional[datetime.tzinfo] = ...) -> datetime.date:
         """
         Get a Date object based on a random date between a given date and 1 day
         ago.
         Accepts date strings that can be recognized by strtotime().
-
+        
         :param start_date: Defaults to "-30d"
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
         :example: dtdate('1999-02-02')
         :return: dtdate
         """
         ...
-    def past_datetime(
-        self,
-        start_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-        tzinfo: Optional[datetime.tzinfo] = ...,
-    ) -> datetime.datetime:
+    def past_datetime(self, start_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ..., tzinfo: Optional[datetime.tzinfo] = ...) -> datetime.datetime:
         """
         Get a datetime object based on a random date between a given date and 1
         second ago.
         Accepts date strings that can be recognized by strtotime().
-
+        
         :param start_date: Defaults to "-30d"
         :param tzinfo: timezone, instance of datetime.tzinfo subclass
         :example: datetime('1999-02-02 11:42:52')
@@ -1182,67 +1067,48 @@ class Faker:
         Generate a random timezone (see `faker.timezone` for any args)
         and return as a python object usable as a `tzinfo` to `datetime`
         or other fakers.
-
+        
         :example: faker.pytimezone()
         :return: dateutil.tz.tz.tzfile
         """
         ...
-    def time(
-        self,
-        pattern: str = ...,
-        end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-    ) -> str:
+    def time(self, pattern: str = ..., end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...) -> str:
         """
         Get a time string (24h format by default)
-
+        
         :param pattern: format
         :example: '15:02:34'
         """
         ...
-    def time_delta(
-        self, end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...
-    ) -> datetime.timedelta:
+    def time_delta(self, end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...) -> datetime.timedelta:
         """
         Get a timedelta object
         """
         ...
-    def time_object(
-        self, end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...
-    ) -> datetime.time:
+    def time_object(self, end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...) -> datetime.time:
         """
         Get a time object
-
+        
         :example: datetime.time(15, 56, 56, 772876)
         """
         ...
-    def time_series(
-        self,
-        start_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-        end_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ...,
-        precision: Optional[float] = ...,
-        distrib: Optional[Callable[[datetime.datetime], float]] = ...,
-        tzinfo: Optional[datetime.tzinfo] = ...,
-    ) -> Iterator[Tuple[datetime.datetime, Any]]:
+    def time_series(self, start_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ..., end_date: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int] = ..., precision: Optional[float] = ..., distrib: Optional[Callable[[datetime.datetime], float]] = ..., tzinfo: Optional[datetime.tzinfo] = ...) -> Iterator[Tuple[datetime.datetime, Any]]:
         """
         Returns a generator yielding tuples of ``(<datetime>, <value>)``.
-
+        
         The data points will start at ``start_date``, and be at every time interval specified by
         ``precision``.
         ``distrib`` is a callable that accepts ``<datetime>`` and returns ``<value>``
         """
         ...
     def timezone(self) -> str: ...
-    def unix_time(
-        self,
-        end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-        start_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...,
-    ) -> float:
+    def unix_time(self, end_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ..., start_datetime: Union[datetime.date, datetime.datetime, datetime.timedelta, str, int, None] = ...) -> float:
         """
         Get a timestamp between January 1, 1970 and now, unless passed
         explicit start_datetime or end_datetime values.
-
+        
         On Windows, the decimal part is always 0.
-
+        
         :example: 1061306726.6
         """
         ...
@@ -1255,11 +1121,11 @@ class Faker:
     def file_extension(self, category: Optional[str] = ...) -> str:
         """
         Generate a file extension under the specified ``category``.
-
+        
         If ``category`` is ``None``, a random category will be used. The list of
         valid categories include: ``'audio'``, ``'image'``, ``'office'``,
         ``'text'``, and ``'video'``.
-
+        
         :sample:
         :sample: category='image'
         """
@@ -1267,7 +1133,7 @@ class Faker:
     def file_name(self, category: Optional[str] = ..., extension: Optional[str] = ...) -> str:
         """
         Generate a random file name with extension.
-
+        
         If ``extension`` is ``None``, a random extension will be created
         under the hood using |file_extension| with the specified
         ``category``. If a value for ``extension`` is provided, the
@@ -1275,7 +1141,7 @@ class Faker:
         The actual name part itself is generated using |word|. If
         extension is an empty string then no extension will be added,
         and file_name will be the same as |word|.
-
+        
         :sample: size=10
         :sample: category='audio'
         :sample: extension='abcdef'
@@ -1283,35 +1149,28 @@ class Faker:
         :sample: extension=''
         """
         ...
-    def file_path(
-        self,
-        depth: int = ...,
-        category: Optional[str] = ...,
-        extension: Union[str, Sequence[str], None] = ...,
-        absolute: Optional[bool] = ...,
-        file_system_rule: Literal["linux", "windows"] = ...,
-    ) -> str:
+    def file_path(self, depth: int = ..., category: Optional[str] = ..., extension: Union[str, Sequence[str], None] = ..., absolute: Optional[bool] = ..., file_system_rule: Literal['linux', 'windows'] = ...) -> str:
         """
         Generate an pathname to a file.
-
+        
         This method uses |file_name| under the hood to generate the file
         name itself, and ``depth`` controls the depth of the directory
         path, and |word| is used under the hood to generate the
         different directory names.
-
+        
         If ``absolute`` is ``True`` (default), the generated path starts
         with ``/`` and is absolute. Otherwise, the generated path is
         relative.
-
+        
         If used, ``extension`` can be either a string, forcing that
         extension, a sequence of strings (one will be picked at random),
         or an empty sequence (the path will have no extension). Default
         behaviour is the same as |file_name|
-
+        
         if ``file_system`` is set (default="linux"), the generated path uses
         specified file system path standard, the list of valid file systems include:
         ``'windows'``, ``'linux'``.
-
+        
         :sample: size=10
         :sample: depth=3
         :sample: depth=5, category='video'
@@ -1325,12 +1184,12 @@ class Faker:
     def mime_type(self, category: Optional[str] = ...) -> str:
         """
         Generate a mime type under the specified ``category``.
-
+        
         If ``category`` is ``None``, a random category will be used. The list of
         valid categories include ``'application'``, ``'audio'``, ``'image'``,
         ``'message'``, ``'model'``, ``'multipart'``, ``'text'``, and
         ``'video'``.
-
+        
         :sample:
         :sample: category='application'
         """
@@ -1338,10 +1197,10 @@ class Faker:
     def unix_device(self, prefix: Optional[str] = ...) -> str:
         """
         Generate a Unix device file name.
-
+        
         If ``prefix`` is ``None``, a random prefix will be used. The list of
         valid prefixes include: ``'sd'``, ``'vd'``, and ``'xvd'``.
-
+        
         :sample:
         :sample: prefix='mmcblk'
         """
@@ -1349,10 +1208,10 @@ class Faker:
     def unix_partition(self, prefix: Optional[str] = ...) -> str:
         """
         Generate a Unix partition name.
-
+        
         This method uses |unix_device| under the hood to create a device file
         name with the specified ``prefix``.
-
+        
         :sample:
         :sample: prefix='mmcblk'
         """
@@ -1383,18 +1242,11 @@ class Faker:
     def ascii_free_email(self) -> str: ...
     def ascii_safe_email(self) -> str: ...
     def company_email(self) -> str: ...
-    def dga(
-        self,
-        year: Optional[int] = ...,
-        month: Optional[int] = ...,
-        day: Optional[int] = ...,
-        tld: Optional[str] = ...,
-        length: Optional[int] = ...,
-    ) -> str:
+    def dga(self, year: Optional[int] = ..., month: Optional[int] = ..., day: Optional[int] = ..., tld: Optional[str] = ..., length: Optional[int] = ...) -> str:
         """
         Generates a domain name by given date
         https://en.wikipedia.org/wiki/Domain_generation_algorithm
-
+        
         :type year: int
         :type month: int
         :type day: int
@@ -1407,7 +1259,7 @@ class Faker:
         """
         Produce an Internet domain name with the specified number of
         subdomain levels.
-
+        
         >>> domain_name()
         nichols-phillips.com
         >>> domain_name(2)
@@ -1421,7 +1273,7 @@ class Faker:
     def hostname(self, levels: int = ...) -> str:
         """
         Produce a hostname with specified number of subdomain levels.
-
+        
         >>> hostname()
         db-01.nichols-phillips.com
         >>> hostname(0)
@@ -1434,7 +1286,7 @@ class Faker:
         """
         Returns random HTTP method
         https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods
-
+        
         :rtype: str
         """
         ...
@@ -1444,10 +1296,10 @@ class Faker:
         https://www.rfc-editor.org/rfc/rfc9110#name-status-codes
         :param include_unassigned: Whether to include status codes which have
             not yet been assigned or are unused
-
+        
         :return: a random three digit status code
         :rtype: int
-
+        
         :example: 404
         """
         ...
@@ -1455,17 +1307,15 @@ class Faker:
         """
         Returns IANA Registrar ID
         https://www.iana.org/assignments/registrar-ids/registrar-ids.xhtml
-
+        
         :rtype: str
         """
         ...
-    def image_url(
-        self, width: Optional[int] = ..., height: Optional[int] = ..., placeholder_url: Optional[str] = ...
-    ) -> str:
+    def image_url(self, width: Optional[int] = ..., height: Optional[int] = ..., placeholder_url: Optional[str] = ...) -> str:
         """
         Returns URL to placeholder image
         Example: http://placehold.it/640x480
-
+        
         :param width: Optional image width
         :param height: Optional image height
         :param placeholder_url: Optional template string of image URLs from custom
@@ -1477,7 +1327,7 @@ class Faker:
     def ipv4(self, network: bool = ..., address_class: Optional[str] = ..., private: Optional[str] = ...) -> str:
         """
         Returns a random IPv4 address or network with a valid CIDR.
-
+        
         :param network: Network address
         :param address_class: IPv4 address class (a, b, or c)
         :param private: Public or private
@@ -1487,14 +1337,14 @@ class Faker:
     def ipv4_network_class(self) -> str:
         """
         Returns a IPv4 network class 'a', 'b' or 'c'.
-
+        
         :returns: IPv4 network class
         """
         ...
     def ipv4_private(self, network: bool = ..., address_class: Optional[str] = ...) -> str:
         """
         Returns a private IPv4.
-
+        
         :param network: Network address
         :param address_class: IPv4 address class (a, b, or c)
         :returns: Private IPv4
@@ -1503,7 +1353,7 @@ class Faker:
     def ipv4_public(self, network: bool = ..., address_class: Optional[str] = ...) -> str:
         """
         Returns a public IPv4 excluding private blocks.
-
+        
         :param network: Network address
         :param address_class: IPv4 address class (a, b, or c)
         :returns: Public IPv4
@@ -1517,7 +1367,7 @@ class Faker:
     def mac_address(self, multicast: bool = ...) -> str:
         """
         Returns a random MAC address.
-
+        
         :param multicast: Multicast address
         :returns: MAC Address
         """
@@ -1526,14 +1376,14 @@ class Faker:
         """
         Returns NIC Handle ID
         https://www.apnic.net/manage-ip/using-whois/guide/person/
-
+        
         :rtype: str
         """
         ...
     def nic_handles(self, count: int = ..., suffix: str = ...) -> List[str]:
         """
         Returns NIC Handle ID list
-
+        
         :rtype: list[str]
         """
         ...
@@ -1541,7 +1391,7 @@ class Faker:
         """
         Returns a network port number
         https://tools.ietf.org/html/rfc6335
-
+        
         :param is_system: System or well-known ports
         :param is_user: User or registered ports
         :param is_dynamic: Dynamic / private / ephemeral ports
@@ -1552,7 +1402,7 @@ class Faker:
         """
         Returns RIPE Organization ID
         https://www.ripe.net/manage-ips-and-asns/db/support/organisation-object-in-the-ripe-database
-
+        
         :rtype: str
         """
         ...
@@ -1588,22 +1438,20 @@ class Faker:
     def isbn10(self, separator: str = ...) -> str: ...
     def isbn13(self, separator: str = ...) -> str: ...
     def job(self) -> str: ...
-    def paragraph(
-        self, nb_sentences: int = ..., variable_nb_sentences: bool = ..., ext_word_list: Optional[Sequence[str]] = ...
-    ) -> str:
+    def paragraph(self, nb_sentences: int = ..., variable_nb_sentences: bool = ..., ext_word_list: Optional[Sequence[str]] = ...) -> str:
         """
         Generate a paragraph.
-
+        
         The ``nb_sentences`` argument controls how many sentences the paragraph
         will contain, and setting ``variable_nb_sentences`` to ``False`` will
         generate the exact amount, while setting it to ``True`` (default) will
         generate a random amount (+/-40%, minimum of 1) using
         |randomize_nb_elements|.
-
+        
         Under the hood, |sentences| is used to generate the sentences, so the
         argument ``ext_word_list`` works in the same way here as it would in
         that method.
-
+        
         :sample: nb_sentences=5
         :sample: nb_sentences=5, variable_nb_sentences=False
         :sample: nb_sentences=5, ext_word_list=['abc', 'def', 'ghi', 'jkl']
@@ -1614,30 +1462,28 @@ class Faker:
     def paragraphs(self, nb: int = ..., ext_word_list: Optional[Sequence[str]] = ...) -> List[str]:
         """
         Generate a list of paragraphs.
-
+        
         This method uses |paragraph| under the hood to generate paragraphs, and
         the ``nb`` argument controls exactly how many sentences the list will
         contain. The ``ext_word_list`` argument works in exactly the same way
         as well.
-
+        
         :sample: nb=5
         :sample: nb=5, ext_word_list=['abc', 'def', 'ghi', 'jkl']
         """
         ...
-    def sentence(
-        self, nb_words: int = ..., variable_nb_words: bool = ..., ext_word_list: Optional[Sequence[str]] = ...
-    ) -> str:
+    def sentence(self, nb_words: int = ..., variable_nb_words: bool = ..., ext_word_list: Optional[Sequence[str]] = ...) -> str:
         """
         Generate a sentence.
-
+        
         The ``nb_words`` argument controls how many words the sentence will
         contain, and setting ``variable_nb_words`` to ``False`` will generate
         the exact amount, while setting it to ``True`` (default) will generate
         a random amount (+/-40%, minimum of 1) using |randomize_nb_elements|.
-
+        
         Under the hood, |words| is used to generate the words, so the argument
         ``ext_word_list`` works in the same way here as it would in that method.
-
+        
         :sample: nb_words=10
         :sample: nb_words=10, variable_nb_words=False
         :sample: nb_words=10, ext_word_list=['abc', 'def', 'ghi', 'jkl']
@@ -1648,12 +1494,12 @@ class Faker:
     def sentences(self, nb: int = ..., ext_word_list: Optional[Sequence[str]] = ...) -> List[str]:
         """
         Generate a list of sentences.
-
+        
         This method uses |sentence| under the hood to generate sentences, and
         the ``nb`` argument controls exactly how many sentences the list will
         contain. The ``ext_word_list`` argument works in exactly the same way
         as well.
-
+        
         :sample:
         :sample: nb=5
         :sample: nb=5, ext_word_list=['abc', 'def', 'ghi', 'jkl']
@@ -1662,30 +1508,28 @@ class Faker:
     def text(self, max_nb_chars: int = ..., ext_word_list: Optional[Sequence[str]] = ...) -> str:
         """
         Generate a text string.
-
+        
         The ``max_nb_chars`` argument controls the approximate number of
         characters the text string will have, and depending on its value, this
         method may use either |words|, |sentences|, or |paragraphs| for text
         generation. The ``ext_word_list`` argument works in exactly the same way
         it would in any of those methods.
-
+        
         :sample: max_nb_chars=20
         :sample: max_nb_chars=80
         :sample: max_nb_chars=160
         :sample: ext_word_list=['abc', 'def', 'ghi', 'jkl']
         """
         ...
-    def texts(
-        self, nb_texts: int = ..., max_nb_chars: int = ..., ext_word_list: Optional[Sequence[str]] = ...
-    ) -> List[str]:
+    def texts(self, nb_texts: int = ..., max_nb_chars: int = ..., ext_word_list: Optional[Sequence[str]] = ...) -> List[str]:
         """
         Generate a list of text strings.
-
+        
         The ``nb_texts`` argument controls how many text strings the list will
         contain, and this method uses |text| under the hood for text generation,
         so the two remaining arguments, ``max_nb_chars`` and ``ext_word_list``
         will work in exactly the same way as well.
-
+        
         :sample: nb_texts=5
         :sample: nb_texts=5, max_nb_chars=50
         :sample: nb_texts=5, max_nb_chars=50,
@@ -1695,44 +1539,38 @@ class Faker:
     def word(self, part_of_speech: Optional[str] = ..., ext_word_list: Optional[Sequence[str]] = ...) -> str:
         """
         Generate a word.
-
+        
         This method uses |words| under the hood with the ``nb`` argument set to
         ``1`` to generate the result.
-
+        
         :sample:
         :sample: ext_word_list=['abc', 'def', 'ghi', 'jkl']
         """
         ...
-    def words(
-        self,
-        nb: int = ...,
-        part_of_speech: Optional[str] = ...,
-        ext_word_list: Optional[Sequence[str]] = ...,
-        unique: bool = ...,
-    ) -> List[str]:
+    def words(self, nb: int = ..., part_of_speech: Optional[str] = ..., ext_word_list: Optional[Sequence[str]] = ..., unique: bool = ...) -> List[str]:
         """
         Generate a tuple of words.
-
+        
         The ``nb`` argument controls the number of words in the resulting list,
         and if ``ext_word_list`` is provided, words from that list will be used
         instead of those from the locale provider's built-in word list.
-
+        
         If ``unique`` is ``True``, this method will return a list containing
         unique words. Under the hood, |random_sample| will be used for sampling
         without replacement. If ``unique`` is ``False``, |random_choices| is
         used instead, and the list returned may contain duplicates.
-
+        
         ``part_of_speech`` is a parameter that defines to what part of speech
         the returned word belongs. If ``ext_word_list`` is not ``None``, then
         ``part_of_speech`` is ignored. If the value of ``part_of_speech`` does
         not correspond to an existent part of speech according to the set locale,
         then an exception is raised.
-
+        
         .. warning::
            Depending on the length of a locale provider's built-in word list or
            on the length of ``ext_word_list`` if provided, a large ``nb`` can
            exhaust said lists if ``unique`` is ``True``, raising an exception.
-
+        
         :sample:
         :sample: nb=5
         :sample: nb=5, ext_word_list=['abc', 'def', 'ghi', 'jkl']
@@ -1742,74 +1580,60 @@ class Faker:
     def binary(self, length: int = ...) -> bytes:
         """
         Generate a random binary blob of ``length`` bytes.
-
+        
         If this faker instance has been seeded, performance will be signficiantly reduced, to conform
         to the seeding.
-
+        
         :sample: length=64
         """
         ...
     def boolean(self, chance_of_getting_true: int = ...) -> bool:
         """
         Generate a random boolean value based on ``chance_of_getting_true``.
-
+        
         :sample: chance_of_getting_true=25
         :sample: chance_of_getting_true=50
         :sample: chance_of_getting_true=75
         """
         ...
-    def csv(
-        self,
-        header: Optional[Sequence[str]] = ...,
-        data_columns: Tuple[str, str] = ...,
-        num_rows: int = ...,
-        include_row_ids: bool = ...,
-    ) -> str:
+    def csv(self, header: Optional[Sequence[str]] = ..., data_columns: Tuple[str, str] = ..., num_rows: int = ..., include_row_ids: bool = ...) -> str:
         """
         Generate random comma-separated values.
-
+        
         For more information on the different arguments of this method, please refer to
         :meth:`dsv() <faker.providers.misc.Provider.dsv>` which is used under the hood.
-
+        
         :sample: data_columns=('{{name}}', '{{address}}'), num_rows=10, include_row_ids=False
         :sample: header=('Name', 'Address', 'Favorite Color'),
                 data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'),
                 num_rows=10, include_row_ids=True
         """
         ...
-    def dsv(
-        self,
-        dialect: str = ...,
-        header: Optional[Sequence[str]] = ...,
-        data_columns: Tuple[str, str] = ...,
-        num_rows: int = ...,
-        include_row_ids: bool = ...,
-        **fmtparams: Any
-    ) -> str:
+    def dsv(self, dialect: str = ..., header: Optional[Sequence[str]] = ..., data_columns: Tuple[str, str] = ..., num_rows: int = ..., include_row_ids: bool = ..., **fmtparams: Any) -> str:
         """
         Generate random delimiter-separated values.
-
+        
         This method's behavior share some similarities with ``csv.writer``. The ``dialect`` and
         ``**fmtparams`` arguments are the same arguments expected by ``csv.writer`` to control its
         behavior, and instead of expecting a file-like object to where output will be written, the
         output is controlled by additional keyword arguments and is returned as a string.
-
+        
         The ``dialect`` argument defaults to ``'faker-csv'`` which is the name of a ``csv.excel``
         subclass with full quoting enabled.
-
+        
         The ``header`` argument expects a list or a tuple of strings that will serve as the header row
         if supplied. The ``data_columns`` argument expects a list or a tuple of string tokens, and these
         string tokens will be passed to  :meth:`pystr_format() <faker.providers.python.Provider.pystr_format>`
         for data generation. Argument Groups are used to pass arguments to the provider methods.
         Both ``header`` and ``data_columns`` must be of the same length.
-
+        
         Example:
             fake.set_arguments('top_half', {'min_value': 50, 'max_value': 100})
             fake.dsv(data_columns=('{{ name }}', '{{ pyint:top_half }}'))
-
+        
         The ``num_rows`` argument controls how many rows of data to generate, and the ``include_row_ids``
         argument may be set to ``True`` to include a sequential row ID column.
-
+        
         :sample: dialect='excel', data_columns=('{{name}}', '{{address}}')
         :sample: dialect='excel-tab', data_columns=('{{name}}', '{{address}}'), include_row_ids=True
         :sample: data_columns=('{{name}}', '{{address}}'), num_rows=5, delimiter='$'
@@ -1818,27 +1642,27 @@ class Faker:
     def fixed_width(self, data_columns: Optional[list] = ..., num_rows: int = ..., align: str = ...) -> str:
         """
         Generate random fixed width values.
-
+        
         Using a list of tuple records that is passed as ``data_columns``, that
         defines the structure that will be generated. Arguments within the
         record are provider specific, and should be a dictionary that will be
         passed to the provider method.
-
+        
         Data Column List format
             [('field width', 'definition', {'arguments'})]
-
+        
         The definition can be 'provider', 'provider:argument_group', tokenized
         'string {{ provider:argument_group }}' that is passed to the python
         provider method pystr_format() for generation, or a fixed '@word'.
         Using Lists, Tuples, and Dicts as a definition for structure.
-
+        
         Argument Groups can be used to pass arguments to the provider methods,
         but will override the arguments supplied in the tuple record.
-
+        
         Example:
             fake.set_arguments('top_half', {'min_value': 50, 'max_value': 100})
             fake.fixed_width(data_columns=[(20, 'name'), (3, 'pyint:top_half')])
-
+        
         :param data_columns: specification for the data structure
         :type data_columns: list
         :param num_rows: number of rows the generator will yield
@@ -1847,70 +1671,58 @@ class Faker:
         :type align: str
         :return: Serialized Fixed Width data
         :rtype: str
-
+        
         :sample: data_columns=[(20, 'name'), (3, 'pyint', {'min_value': 50,
                 'max_value': 100})], align='right', num_rows=2
         """
         ...
-    def image(
-        self,
-        size: Tuple[int, int] = ...,
-        image_format: str = ...,
-        hue: Union[int, Sequence[int], str, None] = ...,
-        luminosity: Optional[str] = ...,
-    ) -> bytes:
+    def image(self, size: Tuple[int, int] = ..., image_format: str = ..., hue: Union[int, Sequence[int], str, None] = ..., luminosity: Optional[str] = ...) -> bytes:
         """
         Generate an image and draw a random polygon on it using the Python Image Library.
         Without it installed, this provider won't be functional. Returns the bytes representing
         the image in a given format.
-
+        
         The argument ``size`` must be a 2-tuple containing (width, height) in pixels. Defaults to 256x256.
-
+        
         The argument ``image_format`` can be any valid format to the underlying library like ``'tiff'``,
         ``'jpeg'``, ``'pdf'`` or ``'png'`` (default). Note that some formats need present system libraries
         prior to building the Python Image Library.
         Refer to https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html for details.
-
+        
         The arguments ``hue`` and ``luminosity`` are the same as in the color provider and are simply forwarded to
         it to generate both the background and the shape colors. Therefore, you can ask for a "dark blue" image, etc.
-
+        
         :sample: size=(2, 2), hue='purple', luminosity='bright', image_format='pdf'
         :sample: size=(16, 16), hue=[90,270], image_format='ico'
         """
         ...
-    def json(
-        self,
-        data_columns: Optional[List] = ...,
-        num_rows: int = ...,
-        indent: Optional[int] = ...,
-        cls: Optional[Type[encoder.JSONEncoder]] = ...,
-    ) -> str:
+    def json(self, data_columns: Optional[List] = ..., num_rows: int = ..., indent: Optional[int] = ..., cls: Optional[Type[encoder.JSONEncoder]] = ...) -> str:
         """
         Generate random JSON structure values.
-
+        
         Using a dictionary or list of records that is passed as ``data_columns``,
         define the structure that is used to build JSON structures.  For complex
         data structures it is recommended to use the dictionary format.
-
+        
         Data Column Dictionary format:
             {'key name': 'definition'}
-
+        
         The definition can be 'provider', 'provider:argument_group', tokenized
         'string {{ provider:argument_group }}' that is passed to the python
         provider method pystr_format() for generation, or a fixed '@word'.
         Using Lists, Tuples, and Dicts as a definition for structure.
-
+        
         Example:
             fake.set_arguments('top_half', {'min_value': 50, 'max_value': 100})
             fake.json(data_columns={'Name': 'name', 'Score': 'pyint:top_half'})
-
+        
         Data Column List format:
             [('key name', 'definition', {'arguments'})]
-
+        
         With the list format the definition can be a list of records, to create
         a list within the structure data.  For literal entries within the list,
         set the 'field_name' to None.
-
+        
         :param data_columns: specification for the data structure
         :type data_columns: dict
         :param num_rows: number of rows the returned
@@ -1921,7 +1733,7 @@ class Faker:
         :type cls: json.JSONEncoder
         :return: Serialized JSON data
         :rtype: str
-
+        
         :sample: data_columns={'Spec': '@1.0.1', 'ID': 'pyint',
                 'Details': {'Name': 'name', 'Address': 'address'}}, num_rows=2
         :sample: data_columns={'Candidates': ['name', 'name', 'name']},
@@ -1930,16 +1742,10 @@ class Faker:
                 {'min_value': 50, 'max_value': 100})], num_rows=1
         """
         ...
-    def json_bytes(
-        self,
-        data_columns: Optional[List] = ...,
-        num_rows: int = ...,
-        indent: Optional[int] = ...,
-        cls: Optional[Type[encoder.JSONEncoder]] = ...,
-    ) -> bytes:
+    def json_bytes(self, data_columns: Optional[List] = ..., num_rows: int = ..., indent: Optional[int] = ..., cls: Optional[Type[encoder.JSONEncoder]] = ...) -> bytes:
         """
         Generate random JSON structure and return as bytes.
-
+        
         For more information on the different arguments of this method, refer to
         :meth:`json() <faker.providers.misc.Provider.json>` which is used under the hood.
         """
@@ -1947,10 +1753,10 @@ class Faker:
     def md5(self, raw_output: bool = ...) -> Union[bytes, str]:
         """
         Generate a random MD5 hash.
-
+        
         If ``raw_output`` is ``False`` (default), a hexadecimal string representation of the MD5 hash
         will be returned. If ``True``, a ``bytes`` object representation will be returned instead.
-
+        
         :sample: raw_output=False
         :sample: raw_output=True
         """
@@ -1960,41 +1766,28 @@ class Faker:
         Generate ``None``, ``True``, or ``False``, each with equal probability.
         """
         ...
-    def password(
-        self,
-        length: int = ...,
-        special_chars: bool = ...,
-        digits: bool = ...,
-        upper_case: bool = ...,
-        lower_case: bool = ...,
-    ) -> str:
+    def password(self, length: int = ..., special_chars: bool = ..., digits: bool = ..., upper_case: bool = ..., lower_case: bool = ...) -> str:
         """
         Generate a random password of the specified ``length``.
-
+        
         The arguments ``special_chars``, ``digits``, ``upper_case``, and ``lower_case`` control
         what category of characters will appear in the generated password. If set to ``True``
         (default), at least one character from the corresponding category is guaranteed to appear.
         Special characters are characters from ``!@#$%^&*()_+``, digits are characters from
         ``0123456789``, and uppercase and lowercase characters are characters from the ASCII set of
         letters.
-
+        
         :sample: length=12
         :sample: length=40, special_chars=False, upper_case=False
         """
         ...
-    def psv(
-        self,
-        header: Optional[Sequence[str]] = ...,
-        data_columns: Tuple[str, str] = ...,
-        num_rows: int = ...,
-        include_row_ids: bool = ...,
-    ) -> str:
+    def psv(self, header: Optional[Sequence[str]] = ..., data_columns: Tuple[str, str] = ..., num_rows: int = ..., include_row_ids: bool = ...) -> str:
         """
         Generate random pipe-separated values.
-
+        
         For more information on the different arguments of this method, please refer to
         :meth:`dsv() <faker.providers.misc.Provider.dsv>` which is used under the hood.
-
+        
         :sample: data_columns=('{{name}}', '{{address}}'), num_rows=10, include_row_ids=False
         :sample: header=('Name', 'Address', 'Favorite Color'),
                 data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'),
@@ -2004,10 +1797,10 @@ class Faker:
     def sha1(self, raw_output: bool = ...) -> Union[bytes, str]:
         """
         Generate a random SHA-1 hash.
-
+        
         If ``raw_output`` is ``False`` (default), a hexadecimal string representation of the SHA-1 hash
         will be returned. If ``True``, a ``bytes`` object representation will be returned instead.
-
+        
         :sample: raw_output=False
         :sample: raw_output=True
         """
@@ -2015,116 +1808,90 @@ class Faker:
     def sha256(self, raw_output: bool = ...) -> Union[bytes, str]:
         """
         Generate a random SHA-256 hash.
-
+        
         If ``raw_output`` is ``False`` (default), a hexadecimal string representation of the SHA-256 hash
         will be returned. If ``True``, a ``bytes`` object representation will be returned instead.
-
+        
         :sample: raw_output=False
         :sample: raw_output=True
         """
         ...
-    def tar(
-        self,
-        uncompressed_size: int = ...,
-        num_files: int = ...,
-        min_file_size: int = ...,
-        compression: Optional[str] = ...,
-    ) -> bytes:
+    def tar(self, uncompressed_size: int = ..., num_files: int = ..., min_file_size: int = ..., compression: Optional[str] = ...) -> bytes:
         """
         Generate a bytes object containing a random valid tar file.
-
+        
         The number and sizes of files contained inside the resulting archive can be controlled
         using the following arguments:
-
+        
         - ``uncompressed_size`` - the total size of files before compression, 16 KiB by default
         - ``num_files`` - the number of files archived in resulting zip file, 1 by default
         - ``min_file_size`` - the minimum size of each file before compression, 4 KiB by default
-
+        
         No compression is used by default, but setting ``compression`` to one of the values listed
         below will use the corresponding compression type.
-
+        
         - ``'bzip2'`` or ``'bz2'`` for BZIP2
         - ``'lzma'`` or ``'xz'`` for LZMA
         - ``'gzip'`` or ``'gz'`` for GZIP
-
+        
         :sample: uncompressed_size=256, num_files=4, min_file_size=32
         :sample: uncompressed_size=256, num_files=32, min_file_size=4, compression='bz2'
         """
         ...
-    def tsv(
-        self,
-        header: Optional[Sequence[str]] = ...,
-        data_columns: Tuple[str, str] = ...,
-        num_rows: int = ...,
-        include_row_ids: bool = ...,
-    ) -> str:
+    def tsv(self, header: Optional[Sequence[str]] = ..., data_columns: Tuple[str, str] = ..., num_rows: int = ..., include_row_ids: bool = ...) -> str:
         """
         Generate random tab-separated values.
-
+        
         For more information on the different arguments of this method, please refer to
         :meth:`dsv() <faker.providers.misc.Provider.dsv>` which is used under the hood.
-
+        
         :sample: data_columns=('{{name}}', '{{address}}'), num_rows=10, include_row_ids=False
         :sample: header=('Name', 'Address', 'Favorite Color'),
                 data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'),
                 num_rows=10, include_row_ids=True
         """
         ...
-    def uuid4(
-        self, cast_to: Union[Callable[[UUID], str], Callable[[UUID], bytes], None] = ...
-    ) -> Union[bytes, str, UUID]:
+    def uuid4(self, cast_to: Union[Callable[[UUID], str], Callable[[UUID], bytes], None] = ...) -> Union[bytes, str, UUID]:
         """
         Generate a random UUID4 object and cast it to another type if specified using a callable ``cast_to``.
-
+        
         By default, ``cast_to`` is set to ``str``.
-
+        
         May be called with ``cast_to=None`` to return a full-fledged ``UUID``.
-
+        
         :sample:
         :sample: cast_to=None
         """
         ...
-    def xml(
-        self,
-        nb_elements: int = ...,
-        variable_nb_elements: bool = ...,
-        value_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-        allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-    ) -> str:
+    def xml(self, nb_elements: int = ..., variable_nb_elements: bool = ..., value_types: Union[List[Type], Tuple[Type, ...], None] = ..., allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...) -> str:
         """
         Returns some XML.
-
+        
         :nb_elements: number of elements for dictionary
         :variable_nb_elements: is use variable number of elements for dictionary
         :value_types: type of dictionary values
-
+        
         Note: this provider required xmltodict library installed
         """
         ...
-    def zip(
-        self,
-        uncompressed_size: int = ...,
-        num_files: int = ...,
-        min_file_size: int = ...,
-        compression: Optional[str] = ...,
-    ) -> bytes:
+    def zip(self, uncompressed_size: int = ..., num_files: int = ..., min_file_size: int = ..., compression: Optional[str] = ...) -> bytes:
         """
         Generate a bytes object containing a random valid zip archive file.
-
+        
         The number and sizes of files contained inside the resulting archive can be controlled
         using the following arguments:
-
+        
         - ``uncompressed_size`` - the total size of files before compression, 16 KiB by default
         - ``num_files`` - the number of files archived in resulting zip file, 1 by default
         - ``min_file_size`` - the minimum size of each file before compression, 4 KiB by default
-
+        
         No compression is used by default, but setting ``compression`` to one of the values listed
         below will use the corresponding compression type.
-
+        
         - ``'bzip2'`` or ``'bz2'`` for BZIP2
         - ``'lzma'`` or ``'xz'`` for LZMA
         - ``'deflate'``, ``'gzip'``, or ``'gz'`` for GZIP
-
+        
         :sample: uncompressed_size=256, num_files=4, min_file_size=32
         :sample: uncompressed_size=256, num_files=32, min_file_size=4, compression='bz2'
         """
@@ -2133,12 +1900,12 @@ class Faker:
         """
         Generates a formatted date of birth, issue, and expiration dates.
         issue and expiration dates are conditioned to fall within U.S. standards of 5 and 10 year expirations
-
-
+        
+        
         The ``birthday`` argument is a datetime.date object representing a date of birth.
-
+        
         Sources:
-
+        
         -https://travel.state.gov/content/travel/en/passports/passport-help/faqs.html
         """
         ...
@@ -2155,9 +1922,9 @@ class Faker:
     def passport_gender(self, seed: int = ...) -> str:
         """
         Generates a string representing the gender displayed on a passport
-
+        
         Sources:
-
+        
         - https://williamsinstitute.law.ucla.edu/publications/x-gender-markers-passports/
         """
         ...
@@ -2210,17 +1977,13 @@ class Faker:
         """
         ...
     def phone_number(self) -> str: ...
-    def profile(
-        self, fields: Optional[List[str]] = ..., sex: Optional[Literal["M", "F"]] = ...
-    ) -> Dict[str, Union[str, Tuple[Decimal, Decimal], List[str], datetime.date]]:
+    def profile(self, fields: Optional[List[str]] = ..., sex: Optional[Literal['M', 'F']] = ...) -> Dict[str, Union[str, Tuple[Decimal, Decimal], List[str], datetime.date]]:
         """
         Generates a complete profile.
         If "fields" is not empty, only the fields in the list will be returned
         """
         ...
-    def simple_profile(
-        self, sex: Optional[Literal["M", "F"]] = ...
-    ) -> Dict[str, Union[str, datetime.date, Literal["M", "F"]]]:
+    def simple_profile(self, sex: Optional[Literal['M', 'F']] = ...) -> Dict[str, Union[str, datetime.date, Literal['M', 'F']]]:
         """
         Generates a basic profile with personal informations
         """
@@ -2228,7 +1991,7 @@ class Faker:
     def enum(self, enum_cls: Type[TEnum]) -> TEnum:
         """
         Returns a random enum of the provided input `Enum` type.
-
+        
         :param enum_cls: The `Enum` type to produce the value for.
         :returns: A randomly selected enum value.
         """
@@ -2236,80 +1999,40 @@ class Faker:
     def pybool(self, truth_probability: int = ...) -> bool:
         """
         Generates a random boolean, optionally biased towards `True` or `False`.
-
+        
         :truth_probability: Probability of generating a `True` value. Must be between `0` and `100` inclusive'.
         :return: Random boolean.
         :raises ValueError: If invalid `truth_probability` is provided.
         """
         ...
-    def pydecimal(
-        self,
-        left_digits: Optional[int] = ...,
-        right_digits: Optional[int] = ...,
-        positive: bool = ...,
-        min_value: Optional[float] = ...,
-        max_value: Optional[float] = ...,
-    ) -> Decimal: ...
-    def pydict(
-        self,
-        nb_elements: int = ...,
-        variable_nb_elements: bool = ...,
-        value_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-        allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-    ) -> Dict[Any, Any]:
+    def pydecimal(self, left_digits: Optional[int] = ..., right_digits: Optional[int] = ..., positive: bool = ..., min_value: Optional[float] = ..., max_value: Optional[float] = ...) -> Decimal: ...
+    def pydict(self, nb_elements: int = ..., variable_nb_elements: bool = ..., value_types: Union[List[Type], Tuple[Type, ...], None] = ..., allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...) -> Dict[Any, Any]:
         """
         Returns a dictionary.
-
+        
         :nb_elements: number of elements for dictionary
         :variable_nb_elements: is use variable number of elements for dictionary
         :value_types: type of dictionary values
         """
         ...
-    def pyfloat(
-        self,
-        left_digits: Optional[int] = ...,
-        right_digits: Optional[int] = ...,
-        positive: Optional[bool] = ...,
-        min_value: Union[float, int, None] = ...,
-        max_value: Union[float, int, None] = ...,
-    ) -> float: ...
+    def pyfloat(self, left_digits: Optional[int] = ..., right_digits: Optional[int] = ..., positive: Optional[bool] = ..., min_value: Union[float, int, None] = ..., max_value: Union[float, int, None] = ...) -> float: ...
     def pyint(self, min_value: int = ..., max_value: int = ..., step: int = ...) -> int: ...
-    def pyiterable(
-        self,
-        nb_elements: int = ...,
-        variable_nb_elements: bool = ...,
-        value_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-        allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-    ) -> Iterable[Any]: ...
-    def pylist(
-        self,
-        nb_elements: int = ...,
-        variable_nb_elements: bool = ...,
-        value_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-        allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-    ) -> List[Any]: ...
-    def pyobject(
-        self, object_type: Optional[Type[Union[bool, str, float, int, tuple, set, list, Iterable, dict]]] = ...
-    ) -> Union[bool, str, float, int, tuple, set, list, Iterable, dict, None]:
+    def pyiterable(self, nb_elements: int = ..., variable_nb_elements: bool = ..., value_types: Union[List[Type], Tuple[Type, ...], None] = ..., allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...) -> Iterable[Any]: ...
+    def pylist(self, nb_elements: int = ..., variable_nb_elements: bool = ..., value_types: Union[List[Type], Tuple[Type, ...], None] = ..., allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...) -> List[Any]: ...
+    def pyobject(self, object_type: Optional[Type[Union[bool, str, float, int, tuple, set, list, Iterable, dict]]] = ...) -> Union[bool, str, float, int, tuple, set, list, Iterable, dict, None]:
         """
         Generates a random object passing the type desired.
-
+        
         :object_type: the type of the object to generate.
         :return: the random object generated.
         :raises ValueError: if the object type passed is not supported
         """
         ...
-    def pyset(
-        self,
-        nb_elements: int = ...,
-        variable_nb_elements: bool = ...,
-        value_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-        allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-    ) -> Set[Any]: ...
+    def pyset(self, nb_elements: int = ..., variable_nb_elements: bool = ..., value_types: Union[List[Type], Tuple[Type, ...], None] = ..., allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...) -> Set[Any]: ...
     def pystr(self, min_chars: Optional[int] = ..., max_chars: int = ..., prefix: str = ..., suffix: str = ...) -> str:
         """
         Generates a random string of upper and lowercase letters.
-
+        
         :param min_chars: minimum length of the random part.
         :param max_chars: maximum length of the random part.
         :param prefix: an optional prefix to prepend to the random string.
@@ -2318,53 +2041,42 @@ class Faker:
         """
         ...
     def pystr_format(self, string_format: str = ..., letters: str = ...) -> str: ...
-    def pystruct(
-        self,
-        count: int = ...,
-        value_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-        allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-    ) -> Tuple[List, Dict, Dict]: ...
-    def pytuple(
-        self,
-        nb_elements: int = ...,
-        variable_nb_elements: bool = ...,
-        value_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-        allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...,
-    ) -> Tuple[Any, ...]: ...
+    def pystruct(self, count: int = ..., value_types: Union[List[Type], Tuple[Type, ...], None] = ..., allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...) -> Tuple[List, Dict, Dict]: ...
+    def pytuple(self, nb_elements: int = ..., variable_nb_elements: bool = ..., value_types: Union[List[Type], Tuple[Type, ...], None] = ..., allowed_types: Union[List[Type], Tuple[Type, ...], None] = ...) -> Tuple[Any, ...]: ...
     def sbn9(self, separator: str = ...) -> str: ...
     def ein(self) -> str:
         """
         Generate a random United States Employer Identification Number (EIN).
-
+        
         An United States An Employer Identification Number (EIN) is
         also known as a Federal Tax Identification Number, and is
         used to identify a business entity. EINs follow a format of a
         two-digit prefix followed by a hyphen and a seven-digit sequence:
         ##-######
-
+        
         https://www.irs.gov/businesses/small-businesses-self-employed/employer-id-numbers
         """
         ...
     def invalid_ssn(self) -> str:
         """
         Generate a random invalid United States Social Security Identification Number (SSN).
-
+        
         Invalid SSNs have the following characteristics:
         Cannot begin with the number 9
         Cannot begin with 666 in positions 1 - 3
         Cannot begin with 000 in positions 1 - 3
         Cannot contain 00 in positions 4 - 5
         Cannot contain 0000 in positions 6 - 9
-
+        
         https://www.ssa.gov/kc/SSAFactSheet--IssuingSSNs.pdf
-
+        
         Additionally, return an invalid SSN that is NOT a valid ITIN by excluding certain ITIN related "group" values
         """
         ...
     def itin(self) -> str:
         """
         Generate a random United States Individual Taxpayer Identification Number (ITIN).
-
+        
         An United States Individual Taxpayer Identification Number
         (ITIN) is a tax processing number issued by the Internal
         Revenue Service. It is a nine-digit number that always begins
@@ -2378,7 +2090,7 @@ class Faker:
     def ssn(self, taxpayer_identification_number_type: str = ...) -> str:
         """
         Generate a random United States Taxpayer Identification Number of the specified type.
-
+        
         If no type is specified, a US SSN is returned.
         """
         ...
@@ -2469,7 +2181,7 @@ class Faker:
     def license_plate_ar(self) -> str:
         """
         Generate a license plate in Arabic characters.
-
+        
         This method first generates a license plate in Latin/Western characters
         using |license_plate_en|, and the result is translated internally to
         generate the Arabic counterpart which serves as this method's return
@@ -2740,7 +2452,7 @@ class Faker:
     def automobile_license_plate(self) -> str:
         """
         Generate an automobile license plate.
-
+        
         .. note::
            Cars, SUVs, vans, trucks, and other 4-wheeled civilian vehicles are
            considered automobiles for this purpose.
@@ -2749,7 +2461,7 @@ class Faker:
     def motorcycle_license_plate(self) -> str:
         """
         Generate a motorcycle license plate.
-
+        
         .. note::
            Motorcycles and any improvised vehicle with a motorcycle as its base
            are issued motorcycle license plates.
@@ -2758,7 +2470,7 @@ class Faker:
     def protocol_license_plate(self) -> str:
         """
         Generate a protocol license plate.
-
+        
         .. note::
            High ranking government officials are entitled to use low numbered
            protocol license plates.
@@ -2772,7 +2484,7 @@ class Faker:
     def english_paragraph(self, nb_sentences: int = ..., variable_nb_sentences: bool = ...) -> str:
         """
         Generate a paragraph in English.
-
+        
         :sample: nb_sentences=5
         :sample: nb_sentences=5, variable_nb_sentences=False
         """
@@ -2780,14 +2492,14 @@ class Faker:
     def english_paragraphs(self, nb: int = ...) -> List[str]:
         """
         Generate a list of paragraphs in English.
-
+        
         :sample: nb=5
         """
         ...
     def english_sentence(self, nb_words: int = ..., variable_nb_words: bool = ...) -> str:
         """
         Generate a sentence in English.
-
+        
         :sample: nb_words=10
         :sample: nb_words=10, variable_nb_words=False
         """
@@ -2795,14 +2507,14 @@ class Faker:
     def english_sentences(self, nb: int = ...) -> List[str]:
         """
         Generate a list of sentences in English.
-
+        
         :sample: nb=5
         """
         ...
     def english_text(self, max_nb_chars: int = ...) -> str:
         """
         Generate a text string in English.
-
+        
         :sample: max_nb_chars=20
         :sample: max_nb_chars=80
         :sample: max_nb_chars=160
@@ -2811,7 +2523,7 @@ class Faker:
     def english_texts(self, nb_texts: int = ..., max_nb_chars: int = ...) -> List[str]:
         """
         Generate a list of text strings in English.
-
+        
         :sample: nb_texts=5
         :sample: nb_texts=5, max_nb_chars=50
         """
@@ -2824,7 +2536,7 @@ class Faker:
     def english_words(self, nb: int = ..., unique: bool = ...) -> List[str]:
         """
         Generate a list of English words.
-
+        
         :sample: nb=5
         :sample: nb=5, unique=True
         """
@@ -2975,7 +2687,7 @@ class Faker:
     def rut(self, min: int = ..., max: int = ...) -> str:
         """
         Generates a RUT within the specified ranges, inclusive.
-
+        
         :param min: Minimum RUT to generate.
         :param max: Maximum RUT to generate.
         :return: a random Chilean RUT between 35.000.000 and 99.999.999
@@ -3024,7 +2736,7 @@ class Faker:
     def license_plate_by_province(self, province_prefix: Optional[str] = ...) -> str:
         """
         Generate a provincial license plate.
-
+        
         If a value for ``province_prefix`` is provided, the value will be used
         as the prefix regardless of validity. If ``None``, then a valid prefix
         will be selected at random.
@@ -3040,13 +2752,13 @@ class Faker:
     def clabe(self, bank_code: Optional[int] = ...) -> str:
         """
         Generate a mexican bank account CLABE.
-
+        
         Sources:
-
+        
         - https://en.wikipedia.org/wiki/CLABE
-
+        
         :return: A fake CLABE number.
-
+        
         :sample:
         :sample: bank_code=2
         """
@@ -3054,19 +2766,19 @@ class Faker:
     def curp(self) -> str:
         """
         See https://es.wikipedia.org/wiki/Clave_%C3%9Anica_de_Registro_de_Poblaci%C3%B3n.
-
+        
         :return: a random Mexican CURP (Unique Population Registry Code)
         """
         ...
-    def elector_code(self, gender: Optional[Literal["H", "M"]] = ...) -> str:
+    def elector_code(self, gender: Optional[Literal['H', 'M']] = ...) -> str:
         """
         Unique elector code issued by INE (Instituto Nacional Electoral) in Mexico.
-
+        
         :param gender: Gender for which to generate the code. Will be randomly
             selected if not provided.
         :type gender: str
         :return: a random INE elector code
-
+        
         :sample:
         :sample: gender='M'
         """
@@ -3074,7 +2786,7 @@ class Faker:
     def rfc(self, natural: bool = ...) -> str:
         """
         See https://es.wikipedia.org/wiki/Registro_Federal_de_Contribuyentes
-
+        
         :param natural: Whether to return the RFC of a natural person.
             Otherwise return the RFC of a legal person.
         :type natural: bool
@@ -3148,7 +2860,7 @@ class Faker:
         It is in fact the result of the concatenation of a siren number (9 digits),
         a sequential number (4 digits) and a control number (1 digit) concatenation.
         If $max_sequential_digits is invalid, it is set to 2.
-
+        
         The siret number is formatted as '### ### ### #####'.
         :param max_sequential_digits The maximum number of digits for the sequential number (> 0 && <= 4).
         """
@@ -3168,7 +2880,7 @@ class Faker:
     def department_number(self) -> str:
         """
         Randomly returns a french department number.
-
+        
         :example: '59'
         """
         ...
@@ -3216,9 +2928,9 @@ class Faker:
     def jan(self, length: int = ...) -> str:
         """
         Generate a JAN barcode of the specified ``length``.
-
+        
         This method is an alias for |JaJpProvider.localized_ean|.
-
+        
         :sample:
         :sample: length=8
         :sample: length=13
@@ -3227,14 +2939,14 @@ class Faker:
     def jan13(self) -> str:
         """
         Generate a 13 digit JAN barcode.
-
+        
         This method is an alias for |JaJpProvider.localized_ean13|.
         """
         ...
     def jan8(self) -> str:
         """
         Generate a 8 digit JAN barcode.
-
+        
         This method is an alias for |JaJpProvider.localized_ean8|.
         """
         ...
@@ -3420,7 +3132,7 @@ class Faker:
     def license_plate_regex_formats(self) -> List[str]:
         """
         Return a regex for matching license plates.
-
+        
         .. warning::
            This is technically not a method that generates fake data, and it
            should not be part of the public API. User should refrain from using
@@ -3431,7 +3143,7 @@ class Faker:
         """
         Returns 14 character Polish National Business Registry Number,
         local entity number.
-
+        
         https://pl.wikipedia.org/wiki/REGON
         """
         ...
@@ -3439,7 +3151,7 @@ class Faker:
         """
         Returns 9 character Polish National Business Registry Number,
         Polish: Rejestr Gospodarki Narodowej - REGON.
-
+        
         https://pl.wikipedia.org/wiki/REGON
         """
         ...
@@ -3447,10 +3159,10 @@ class Faker:
         """
         Returns 9 character Polish Identity Card Number,
         Polish: Numer Dowodu Osobistego.
-
+        
         The card number consists of 3 letters followed by 6 digits (for example, ABA300000),
         of which the first digit (at position 3) is the check digit.
-
+        
         https://en.wikipedia.org/wiki/Polish_identity_card
         """
         ...
@@ -3458,7 +3170,7 @@ class Faker:
         """
         Returns 10 digit of Number of tax identification.
         Polish: Numer identyfikacji podatkowej (NIP).
-
+        
         https://pl.wikipedia.org/wiki/NIP
         list of codes
         http://www.algorytm.org/numery-identyfikacyjne/nip.html
@@ -3468,7 +3180,7 @@ class Faker:
         """
         Returns 11 characters of Universal Electronic System for Registration of the Population.
         Polish: Powszechny Elektroniczny System Ewidencji Ludności.
-
+        
         PESEL has 11 digits which identifies just one person.
         pesel_date: if person was born in
             * 1900-1999 - month field number is not modified
@@ -3477,9 +3189,9 @@ class Faker:
             * 2200–2299 – month + 60
             * 1800–1899 – month + 80
             * outside range 1800-2299 function will raise ValueError
-
+        
         pesel_sex: last digit identifies person's sex. Even for females, odd for males.
-
+        
         https://en.wikipedia.org/wiki/PESEL
         """
         ...
@@ -3488,7 +3200,7 @@ class Faker:
         """
         Function generates an identification number for medical doctors
         Polish: Prawo Wykonywania Zawodu (PWZ)
-
+        
         https://www.nil.org.pl/rejestry/centralny-rejestr-lekarzy/zasady-weryfikowania-nr-prawa-wykonywania-zawodu
         """
         ...
@@ -3497,7 +3209,7 @@ class Faker:
         """
         Function generates an identification number for nurses and midwives
         Polish: Prawo Wykonywania Zawodu (PWZ)
-
+        
         http://arch.nipip.pl/index.php/prawo/uchwaly/naczelnych-rad/w-roku-2015/posiedzenie-15-17-grudnia/3664-uchwala-
         nr-381-vi-2015-w-sprawie-trybu-postepowania-dotyczacego-stwierdzania-i-przyznawania-prawa-wykonywania-zawodu-pi
         elegniarki-i-zawodu-poloznej-oraz-sposobu-prowadzenia-rejestru-pielegniarek-i-rejestru-poloznych-przez-okregowe
@@ -3597,7 +3309,7 @@ class Faker:
     def bic(self) -> str:
         """
         Generate a bank identification code (BIC).
-
+        
         BIC is a bank identification code that is used in Russia.
         See https://ru.wikipedia.org/wiki/Банковский_идентификационный_код.
         """
@@ -3605,7 +3317,7 @@ class Faker:
     def checking_account(self) -> str:
         """
         Generate a checking account number.
-
+        
         Checking account is used in banks to handle financial operations of
         clients.
         See https://ru.wikipedia.org/wiki/Расчётный_счёт.
@@ -3614,7 +3326,7 @@ class Faker:
     def correspondent_account(self) -> str:
         """
         Generate a correspondent account number.
-
+        
         Correspondent account is established to handle various financial
         operations between financial institutions.
         See https://ru.wikipedia.org/wiki/Корреспондентский_счёт.
@@ -3693,14 +3405,14 @@ class Faker:
     def diplomatic_license_plate(self) -> str:
         """
         Example: 'CDP 000'  or 'DP 000 000' or 'S 000 000' format
-
+        
         :sample:
         """
         ...
     def plate_letter_prefix(self, region_name: Optional[str] = ...) -> str:
         """
         Generate a letter for license plates.
-
+        
         :sample:
         :sample: region_name="Kyiv"
         """
@@ -3708,27 +3420,27 @@ class Faker:
     def plate_letter_suffix(self) -> str:
         """
         Generate a end letter for license plates.
-
+        
         :sample:
         """
         ...
     def plate_region_code(self, region_name: Optional[str] = ...) -> str:
         """
         Generate plate region number
-
+        
         :sample:
         :sample: region_name="Kyiv"
         """
         ...
-    def full_name(self, gender: Optional[Literal["M", "F"]] = ..., short: Optional[bool] = ...) -> str:
+    def full_name(self, gender: Optional[Literal['M', 'F']] = ..., short: Optional[bool] = ...) -> str:
         """
         Generate Full Name
             - gender = 'M' or 'F' optional params
             - short: bool optional params. default is False
-
+        
         :example: 'Петриченко Петро Сергійович'
         :example: 'Петриченко П.С.'
-
+        
         :sample:
         :sample: gender='F'
         :sample: gender='M'
@@ -3746,59 +3458,51 @@ class Faker:
         Default dir() implementation.
         """
         ...
-    def __getattr__(self, attr: "str") -> "Any":
+    def __getattr__(self, attr: 'str') -> 'Any':
         """
         Handles cache access and proxying behavior
-
+        
         :param attr: attribute name
         :return: the appropriate attribute
         """
         ...
-    def __getattribute__(self, attr: "str") -> "Any":
+    def __getattribute__(self, attr: 'str') -> 'Any':
         """
         Handles the "attribute resolution" behavior for declared members of this proxy class
-
+        
         The class method `seed` cannot be called from an instance.
-
+        
         :param attr: attribute name
         :return: the appropriate attribute
         """
         ...
-    def __getitem__(self, locale: "str") -> "Faker": ...
-    def __init__(
-        self,
-        locale: "str | Sequence[str] | dict[str, int | float] | None" = ...,
-        providers: "list[str] | None" = ...,
-        generator: "Generator | None" = ...,
-        includes: "list[str] | None" = ...,
-        use_weighting: "bool" = ...,
-        **config: "Any"
-    ) -> "None":
+    def __getitem__(self, locale: 'str') -> 'Faker': ...
+    def __init__(self, locale: 'str | Sequence[str] | dict[str, int | float] | None' = ..., providers: 'list[str] | None' = ..., generator: 'Generator | None' = ..., includes: 'list[str] | None' = ..., use_weighting: 'bool' = ..., **config: 'Any') -> 'None':
         """
         Initialize self.  See help(type(self)) for accurate signature.
         """
         ...
-    def __setstate__(self, state: "Any") -> "None": ...
-    def items(self) -> "list[tuple[str, Generator | Faker]]": ...
+    def __setstate__(self, state: 'Any') -> 'None': ...
+    def items(self) -> 'list[tuple[str, Generator | Faker]]': ...
     @staticmethod
-    def seed(seed: "SeedType | None" = ...) -> "None":
+    def seed(seed: 'SeedType | None' = ...) -> 'None':
         """
         Hashables the shared `random.Random` object across all factories
-
+        
         :param seed: seed value
         """
         ...
-    def seed_instance(self, seed: "SeedType | None" = ...) -> "None":
+    def seed_instance(self, seed: 'SeedType | None' = ...) -> 'None':
         """
         Creates and seeds a new `random.Random` object for each factory
-
+        
         :param seed: seed value
         """
         ...
-    def seed_locale(self, locale: "str", seed: "SeedType | None" = ...) -> "None":
+    def seed_locale(self, locale: 'str', seed: 'SeedType | None' = ...) -> 'None':
         """
         Creates and seeds a new `random.Random` object for the factory of the specified locale
-
+        
         :param locale: locale string
         :param seed: seed value
         """


Test patch:
diff --git a/tests/providers/test_person.py b/tests/providers/test_person.py
index 19ca4a6f..ee5ac157 100644
--- a/tests/providers/test_person.py
+++ b/tests/providers/test_person.py
@@ -36,6 +36,7 @@ from faker.providers.person.ta_IN import Provider as TaINProvider
 from faker.providers.person.th_TH import Provider as ThThProvider
 from faker.providers.person.uk_UA import Provider as UkUAProvider
 from faker.providers.person.uk_UA import translit as UkUATranslit
+from faker.providers.person.yo_NG import Provider as YoNGProvider
 from faker.providers.person.zh_CN import Provider as ZhCNProvider
 from faker.providers.person.zh_TW import Provider as ZhTWProvider
 from faker.providers.person.zu_ZA import Provider as ZuZAProvider
@@ -1397,6 +1398,85 @@ class TestGaIE(TestEnIE):
         Faker.seed(0)
 
 
+class TestYoNG(unittest.TestCase):
+    def setUp(self):
+        self.fake = Faker("yo_NG")
+        Faker.seed(0)
+
+    def test_last_name(self):
+        """
+        Test the generation of Zulu last names.
+        """
+        # There's no gender-specific last name in Zulu.
+        self.assertTrue(hasattr(YoNGProvider, "last_names_male"))
+        self.assertTrue(hasattr(YoNGProvider, "last_names_female"))
+
+        # All last names apply to all genders.
+        self.assertTrue(hasattr(YoNGProvider, "last_names"))
+
+        # General last name.
+        name = self.fake.last_name()
+        self.assertIsInstance(name, str)
+        self.assertIn(name, YoNGProvider.last_names)
+
+        # Females last name.
+        name = self.fake.last_name_female()
+        self.assertIsInstance(name, str)
+        self.assertIn(name, YoNGProvider.last_names)
+
+        # Male last name.
+        name = self.fake.last_name_male()
+        self.assertIsInstance(name, str)
+        self.assertIn(name, YoNGProvider.last_names)
+
+    def test_first_name(self):
+        """
+        Test the generation of Zulu first names.
+        """
+        # General first name.
+        name = self.fake.first_name()
+        self.assertIsInstance(name, str)
+        self.assertIn(name, YoNGProvider.first_names)
+
+        # Female first name.
+        name = self.fake.first_name_female()
+        self.assertIsInstance(name, str)
+        self.assertIn(name, YoNGProvider.first_names)
+        self.assertIn(name, YoNGProvider.first_names_female)
+
+        # Male first name.
+        name = self.fake.first_name_male()
+        self.assertIsInstance(name, str)
+        self.assertIn(name, YoNGProvider.first_names)
+        self.assertIn(name, YoNGProvider.first_names_male)
+
+    def test_full_name(self):
+        """
+        Test the generation of full Zulu names.
+        """
+        # Full name.
+        name = self.fake.name()
+        self.assertIsInstance(name, str)
+
+        full_name_parts = name.split()
+
+        if len(full_name_parts) == 2:
+            first_name = full_name_parts[0]
+            last_name = full_name_parts[1]
+            self.assertIn(first_name, YoNGProvider.first_names)
+            self.assertIn(last_name, YoNGProvider.last_names)
+        elif len(full_name_parts) == 3:
+            prefix = full_name_parts[0]
+            first_name = full_name_parts[1]
+            last_name = full_name_parts[2]
+
+            self.assertIn(prefix, YoNGProvider.prefixes_female + YoNGProvider.prefixes_male)
+            self.assertIn(first_name, YoNGProvider.first_names)
+            self.assertIn(last_name, YoNGProvider.last_names)
+        else:
+            raise AssertionError("Invalid number of name parts. Expected 2 or 3.")
+
+
 class TestZuZa(unittest.TestCase):
     def setUp(self):
         self.fake = Faker("zu_ZA")