update bots

.venv/lib/python3.12/site-packages/faker/__init__.py

@@ -0,0 +1,7 @@
+from faker.factory import Factory
+from faker.generator import Generator
+from faker.proxy import Faker
+
+VERSION = "40.18.0"
+
+__all__ = ("Factory", "Generator", "Faker")

.venv/lib/python3.12/site-packages/faker/__main__.py

@@ -0,0 +1,4 @@
+if __name__ == "__main__":
+    from .cli import execute_from_command_line
+
+    execute_from_command_line()

.venv/lib/python3.12/site-packages/faker/cli.py

@@ -0,0 +1,310 @@
+import argparse
+import itertools
+import logging
+import os
+import random
+import sys
+import textwrap
+
+from io import TextIOWrapper
+from pathlib import Path
+from typing import Dict, List, Optional, TextIO, TypeVar, Union
+
+from . import VERSION, Faker, documentor, exceptions
+from .config import AVAILABLE_LOCALES, DEFAULT_LOCALE, META_PROVIDERS_MODULES
+from .documentor import Documentor
+from .providers import BaseProvider
+
+__author__ = "joke2k"
+
+T = TypeVar("T")
+
+
+def _encode_for_output(value: str, output: TextIO) -> str:
+    encoding = getattr(output, "encoding", None)
+    if encoding is None:
+        return value
+
+    try:
+        value.encode(encoding)
+    except UnicodeEncodeError:
+        return value.encode(encoding, errors="backslashreplace").decode(encoding)
+
+    return value
+
+
+def print_provider(
+    doc: Documentor,
+    provider: BaseProvider,
+    formatters: Dict[str, T],
+    excludes: Optional[List[str]] = None,
+    output: Optional[TextIO] = None,
+) -> None:
+    if output is None:
+        output = sys.stdout
+    if excludes is None:
+        excludes = []
+
+    print(file=output)
+    print(_encode_for_output(f"### {doc.get_provider_name(provider)}", output), file=output)
+    print(file=output)
+
+    margin = max(30, doc.max_name_len + 2)
+    for signature, example in formatters.items():
+        if signature in excludes:
+            continue
+        signature_lines = textwrap.wrap(signature, width=margin, subsequent_indent="  ")
+        try:
+            lines = textwrap.wrap(
+                str(example).expandtabs(),
+                width=150 - margin,
+                initial_indent="# ",
+                subsequent_indent="  ",
+            )
+        except UnicodeDecodeError:
+            # The example is actually made of bytes.
+            # We could coerce to bytes, but that would fail anyway when we wiil
+            # try to `print` the line.
+            lines = ["<bytes>"]
+        except UnicodeEncodeError:
+            raise Exception(f"error on {signature!r} with value {example!r}")
+        for left, right in itertools.zip_longest(signature_lines, lines, fillvalue=""):
+            line = f"\t{left:<{margin}}  {right}"
+            print(_encode_for_output(line, output), file=output)
+
+
+def print_doc(
+    provider_or_field: Optional[str] = None,
+    args: Optional[List[T]] = None,
+    lang: str = DEFAULT_LOCALE,
+    output: Optional[Union[TextIO, TextIOWrapper]] = None,
+    seed: Optional[float] = None,
+    includes: Optional[List[str]] = None,
+) -> None:
+    if args is None:
+        args = []
+    if output is None:
+        output = sys.stdout
+    fake = Faker(locale=lang, includes=includes)
+    fake.seed_instance(seed)
+
+    from faker.providers import BaseProvider
+
+    base_provider_formatters = list(dir(BaseProvider))
+
+    if provider_or_field:
+        if "." in provider_or_field:
+            parts = provider_or_field.split(".")
+            locale = parts[-2] if parts[-2] in AVAILABLE_LOCALES else lang
+            fake = Faker(locale, providers=[provider_or_field], includes=includes)
+            fake.seed_instance(seed)
+            doc = documentor.Documentor(fake)
+            doc.already_generated = base_provider_formatters
+            print_provider(
+                doc,
+                fake.get_providers()[0],
+                doc.get_provider_formatters(fake.get_providers()[0]),
+                output=output,
+            )
+        else:
+            try:
+                print(fake.format(provider_or_field, *args), end="", file=output)
+            except AttributeError:
+                raise ValueError(f'No faker found for "{provider_or_field}({args})"')
+
+    else:
+        doc = documentor.Documentor(fake)
+        unsupported: List[str] = []
+
+        while True:
+            try:
+                formatters = doc.get_formatters(with_args=True, with_defaults=True, excludes=unsupported)
+            except exceptions.UnsupportedFeature as e:
+                unsupported.append(e.name)
+            else:
+                break
+
+        for provider, fakers in formatters:
+            print_provider(doc, provider, fakers, output=output)
+
+
+class Command:
+    def __init__(self, argv: Optional[str] = None) -> None:
+        self.argv = argv or sys.argv[:]
+        self.prog_name = Path(self.argv[0]).name
+
+    def execute(self) -> None:
+        """
+        Given the command-line arguments, this creates a parser appropriate
+        to that command, and runs it.
+        """
+
+        # retrieve default language from system environment
+        default_locale = os.environ.get("LANG", "en_US").split(".")[0]
+        if default_locale not in AVAILABLE_LOCALES:
+            default_locale = DEFAULT_LOCALE
+
+        epilog = f"""supported locales:
+
+  {', '.join(sorted(AVAILABLE_LOCALES))}
+
+  Faker can take a locale as an optional argument, to return localized data. If
+  no locale argument is specified, the factory falls back to the user's OS
+  locale as long as it is supported by at least one of the providers.
+     - for this user, the default locale is {default_locale}.
+
+  If the optional argument locale and/or user's default locale is not available
+  for the specified provider, the factory falls back to faker's default locale,
+  which is {DEFAULT_LOCALE}.
+
+examples:
+
+  $ faker address
+  968 Bahringer Garden Apt. 722
+  Kristinaland, NJ 09890
+
+  $ faker -l de_DE address
+  Samira-Niemeier-Allee 56
+  94812 Biedenkopf
+
+  $ faker profile ssn,birthdate
+  {{'ssn': u'628-10-1085', 'birthdate': '2008-03-29'}}
+
+  $ faker -r=3 -s=";" name
+  Willam Kertzmann;
+  Josiah Maggio;
+  Gayla Schmitt;
+
+"""
+
+        formatter_class = argparse.RawDescriptionHelpFormatter
+        parser = argparse.ArgumentParser(
+            prog=self.prog_name,
+            description=f"{self.prog_name} version {VERSION}",
+            epilog=epilog,
+            formatter_class=formatter_class,
+        )
+
+        parser.add_argument("--version", action="version", version=f"%(prog)s {VERSION}")
+
+        parser.add_argument(
+            "-v",
+            "--verbose",
+            action="store_true",
+            help="show INFO logging events instead "
+            "of CRITICAL, which is the default. These logging "
+            "events provide insight into localization of "
+            "specific providers.",
+        )
+
+        parser.add_argument(
+            "-o",
+            metavar="output",
+            type=argparse.FileType("w"),
+            default=sys.stdout,
+            help="redirect output to a file",
+        )
+
+        parser.add_argument(
+            "-l",
+            "--lang",
+            choices=AVAILABLE_LOCALES,
+            default=default_locale,
+            metavar="LOCALE",
+            help="specify the language for a localized provider (e.g. de_DE)",
+        )
+        parser.add_argument(
+            "-r",
+            "--repeat",
+            default=1,
+            type=int,
+            help="generate the specified number of outputs",
+        )
+        parser.add_argument(
+            "-s",
+            "--sep",
+            default="\n",
+            help="use the specified separator after each output",
+        )
+
+        parser.add_argument(
+            "--seed",
+            metavar="SEED",
+            type=int,
+            help="specify a seed for the random generator so "
+            "that results are repeatable. Also compatible "
+            "with 'repeat' option",
+        )
+
+        parser.add_argument(
+            "-i",
+            "--include",
+            action="append",
+            help="list of additional custom providers to "
+            "user, given as the import path of the module "
+            "containing your Provider class (not the provider "
+            "class itself)",
+        )
+
+        parser.add_argument(
+            "fake",
+            action="store",
+            nargs="?",
+            help="name of the fake to generate output for (e.g. profile)",
+        )
+
+        parser.add_argument(
+            "fake_args",
+            metavar="fake argument",
+            action="store",
+            nargs="*",
+            help="optional arguments to pass to the fake "
+            "(e.g. the profile fake takes an optional "
+            "list of comma separated field names as the "
+            "first argument)",
+        )
+
+        arguments = parser.parse_args(self.argv[1:])
+        if arguments.include is None:
+            arguments.include = META_PROVIDERS_MODULES
+
+        if arguments.verbose:
+            logging.basicConfig(level=logging.DEBUG)
+        else:
+            logging.basicConfig(level=logging.CRITICAL)
+
+        random.seed(arguments.seed)
+        seeds = [random.random() for _ in range(arguments.repeat)]
+
+        for i in range(arguments.repeat):
+            print_doc(
+                arguments.fake,
+                arguments.fake_args,
+                lang=arguments.lang,
+                output=arguments.o,
+                seed=seeds[i],
+                includes=arguments.include,
+            )
+            print(arguments.sep, file=arguments.o)
+
+            if not arguments.fake:
+                # repeat not supported for all docs
+                break
+
+
+def execute_from_command_line(argv: Optional[str] = None) -> None:
+    """A simple method that runs a Command."""
+    if sys.stdout.encoding is None:
+        print(
+            "please set python env PYTHONIOENCODING=UTF-8, example: "
+            "export PYTHONIOENCODING=UTF-8, when writing to stdout",
+            file=sys.stderr,
+        )
+        exit(1)
+
+    command = Command(argv)
+    command.execute()
+
+
+if __name__ == "__main__":
+    execute_from_command_line()

.venv/lib/python3.12/site-packages/faker/config.py

@@ -0,0 +1,13 @@
+from importlib import import_module
+
+from .utils.loading import find_available_locales, find_available_providers
+
+DEFAULT_LOCALE = "en_US"
+
+META_PROVIDERS_MODULES = [
+    "faker.providers",
+]
+
+PROVIDERS = find_available_providers([import_module(path) for path in META_PROVIDERS_MODULES])
+
+AVAILABLE_LOCALES = find_available_locales(PROVIDERS)

.venv/lib/python3.12/site-packages/faker/contrib/pytest/plugin.py

@@ -0,0 +1,38 @@
+import pytest
+
+from faker import Faker
+from faker.config import DEFAULT_LOCALE
+
+DEFAULT_SEED = 0
+
+
+@pytest.fixture(scope="session", autouse=True)
+def _session_faker(request):
+    """Fixture that stores the session level ``Faker`` instance.
+
+    This fixture is internal and is only meant for use within the project.
+    Third parties should instead use the ``faker`` fixture for their tests.
+    """
+    if "faker_session_locale" in request.fixturenames:
+        locale = request.getfixturevalue("faker_session_locale")
+    else:
+        locale = [DEFAULT_LOCALE]
+    return Faker(locale=locale)
+
+
+@pytest.fixture()
+def faker(request):
+    """Fixture that returns a seeded and suitable ``Faker`` instance."""
+    if "faker_locale" in request.fixturenames:
+        locale = request.getfixturevalue("faker_locale")
+        fake = Faker(locale=locale)
+    else:
+        fake = request.getfixturevalue("_session_faker")
+
+    seed = DEFAULT_SEED
+    if "faker_seed" in request.fixturenames:
+        seed = request.getfixturevalue("faker_seed")
+    fake.seed_instance(seed=seed)
+    fake.unique.clear()
+
+    return fake

.venv/lib/python3.12/site-packages/faker/decode/__init__.py

@@ -0,0 +1,13 @@
+from .codes import codes
+
+
+def unidecode(txt: str) -> str:
+    chars = ""
+    for ch in txt:
+        codepoint = ord(ch)
+
+        try:
+            chars += codes[codepoint]
+        except IndexError:
+            pass
+    return chars

.venv/lib/python3.12/site-packages/faker/documentor.py

@@ -0,0 +1,127 @@
+import inspect
+import warnings
+
+from enum import Enum, auto
+from typing import Any, Dict, List, Optional, Tuple, Type, Union
+
+from .generator import Generator
+from .providers import BaseProvider
+from .proxy import Faker
+
+
+class FakerEnum(Enum):
+    """Required for faker.providers.enum"""
+
+    A = auto
+    B = auto
+
+
+class Documentor:
+    def __init__(self, generator: Union[Generator, Faker]) -> None:
+        """
+        :param generator: a localized Generator with providers filled,
+                          for which to write the documentation
+        :type generator: faker.Generator()
+        """
+        self.generator = generator
+        self.max_name_len: int = 0
+        self.already_generated: List[str] = []
+
+    def get_formatters(
+        self,
+        locale: Optional[str] = None,
+        excludes: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> List[Tuple[BaseProvider, Dict[str, str]]]:
+        self.max_name_len = 0
+        self.already_generated = [] if excludes is None else excludes[:]
+        formatters = []
+        providers: List[BaseProvider] = self.generator.get_providers()
+        for provider in providers[::-1]:  # reverse
+            if locale and provider.__lang__ and provider.__lang__ != locale:
+                continue
+            formatters.append(
+                (provider, self.get_provider_formatters(provider, **kwargs)),
+            )
+        return formatters
+
+    def get_provider_formatters(
+        self,
+        provider: BaseProvider,
+        prefix: str = "fake.",
+        with_args: bool = True,
+        with_defaults: bool = True,
+    ) -> Dict[str, str]:
+        formatters = {}
+
+        for name, method in inspect.getmembers(provider, inspect.ismethod):
+            # skip 'private' method and inherited methods
+            if name.startswith("_") or name in self.already_generated:
+                continue
+
+            arguments = []
+            faker_args: List[Union[str, Type[Enum]]] = []
+            faker_kwargs = {}
+
+            if name == "binary":
+                faker_kwargs["length"] = 1024
+            elif name in ["zip", "tar"]:
+                faker_kwargs.update(
+                    {
+                        "uncompressed_size": 1024,
+                        "min_file_size": 512,
+                    }
+                )
+
+            if name == "enum":
+                faker_args = [FakerEnum]
+
+            if with_args:
+                # retrieve all parameter
+                argspec = inspect.getfullargspec(method)
+
+                lst = [x for x in argspec.args if x not in ["self", "cls"]]
+                for i, arg in enumerate(lst):
+                    if argspec.defaults and with_defaults:
+                        try:
+                            default = argspec.defaults[i]
+                            if isinstance(default, str):
+                                default = repr(default)
+                            else:
+                                # TODO check default type
+                                default = f"{default}"
+
+                            arg = f"{arg}={default}"
+
+                        except IndexError:
+                            pass
+
+                    arguments.append(arg)
+                    if with_args == "first":
+                        break
+
+                if with_args != "first":
+                    if argspec.varargs:
+                        arguments.append("*" + argspec.varargs)
+                    if argspec.varkw:
+                        arguments.append("**" + argspec.varkw)
+
+            # build fake method signature
+            signature = f"{prefix}{name}({', '.join(arguments)})"
+
+            try:
+                # make a fake example
+                example = self.generator.format(name, *faker_args, **faker_kwargs)
+            except (AttributeError, ValueError) as e:
+                warnings.warn(str(e))
+                continue
+            formatters[signature] = example
+
+            self.max_name_len = max(self.max_name_len, *(len(part) for part in signature.split()))
+            self.already_generated.append(name)
+
+        return formatters
+
+    @staticmethod
+    def get_provider_name(provider_class: BaseProvider) -> str:
+        return provider_class.__provider__

.venv/lib/python3.12/site-packages/faker/exceptions.py

@@ -0,0 +1,16 @@
+class BaseFakerException(Exception):
+    """The base exception for all Faker exceptions."""
+
+
+class UniquenessException(BaseFakerException):
+    """To avoid infinite loops, after a certain number of attempts,
+    the "unique" attribute of the Proxy will throw this exception.
+    """
+
+
+class UnsupportedFeature(BaseFakerException):
+    """The requested feature is not available on this system."""
+
+    def __init__(self, msg: str, name: str) -> None:
+        self.name = name
+        super().__init__(msg)

.venv/lib/python3.12/site-packages/faker/factory.py

@@ -0,0 +1,114 @@
+import functools
+import locale as pylocale
+import logging
+import sys
+
+from importlib import import_module
+from typing import Any, List, Optional, Tuple
+
+from .config import AVAILABLE_LOCALES, DEFAULT_LOCALE, PROVIDERS
+from .generator import Generator
+from .utils.loading import list_module
+
+logger = logging.getLogger(__name__)
+
+# identify if python is being run in interactive mode. If so, disable logging.
+inREPL = bool(getattr(sys, "ps1", False))
+if inREPL:
+    logger.setLevel(logging.CRITICAL)
+else:
+    logger.debug("Not in REPL -> leaving logger event level as is.")
+
+
+class Factory:
+    @classmethod
+    def create(
+        cls,
+        locale: Optional[str] = None,
+        providers: Optional[List[str]] = None,
+        generator: Optional[Generator] = None,
+        includes: Optional[List[str]] = None,
+        # Should we use weightings (more realistic) or weight every element equally (faster)?
+        # By default, use weightings for backwards compatibility & realism
+        use_weighting: bool = True,
+        **config: Any,
+    ) -> Generator:
+        if includes is None:
+            includes = []
+
+        # fix locale to package name
+        locale = locale.replace("-", "_") if locale else DEFAULT_LOCALE
+        locale = pylocale.normalize(locale).split(".")[0]
+        if locale not in AVAILABLE_LOCALES:
+            msg = f"Invalid configuration for faker locale `{locale}`"
+            raise AttributeError(msg)
+
+        config["locale"] = locale
+        config["use_weighting"] = use_weighting
+        _providers = (providers or PROVIDERS) + includes
+
+        faker = generator or Generator(**config)
+
+        for prov_name in _providers:
+            if prov_name == "faker.providers":
+                continue
+
+            prov_cls, lang_found, _ = cls._find_provider_class(prov_name, locale)
+            provider = prov_cls(faker)
+            provider.__use_weighting__ = use_weighting
+            provider.__provider__ = prov_name
+            provider.__lang__ = lang_found
+            faker.add_provider(provider)
+
+        return faker
+
+    @classmethod
+    @functools.lru_cache(maxsize=None)
+    def _find_provider_class(
+        cls,
+        provider_path: str,
+        locale: Optional[str] = None,
+    ) -> Tuple[Any, Optional[str], Optional[str]]:
+        provider_module = import_module(provider_path)
+        default_locale = getattr(provider_module, "default_locale", "")
+
+        if getattr(provider_module, "localized", False):
+            logger.debug(
+                "Looking for locale `%s` in provider `%s`.",
+                locale,
+                provider_module.__name__,
+            )
+
+            available_locales = list_module(provider_module)
+            if not locale or locale not in available_locales:
+                unavailable_locale = locale
+                locale = default_locale or DEFAULT_LOCALE
+                logger.debug(
+                    "Specified locale `%s` is not available for "
+                    "provider `%s`. Locale reset to `%s` for this "
+                    "provider.",
+                    unavailable_locale,
+                    provider_module.__name__,
+                    locale,
+                )
+            else:
+                logger.debug(
+                    "Provider `%s` has been localized to `%s`.",
+                    provider_module.__name__,
+                    locale,
+                )
+
+            path = f"{provider_path}.{locale}"
+            provider_module = import_module(path)
+
+        else:
+            if locale:
+                logger.debug(
+                    "Provider `%s` does not feature localization. "
+                    "Specified locale `%s` is not used for this provider.",
+                    provider_module.__name__,
+                    locale,
+                )
+            locale = default_locale = None
+
+        return provider_module.Provider, locale, default_locale  # type: ignore

.venv/lib/python3.12/site-packages/faker/generator.py

@@ -0,0 +1,191 @@
+import random as random_module
+import re
+
+from typing import TYPE_CHECKING, Any, Callable, Dict, Hashable, List, Optional, Type, Union
+
+from .typing import SeedType
+
+if TYPE_CHECKING:
+    from .providers import BaseProvider
+
+_re_token = re.compile(r"\{\{\s*(\w+)(:\s*\w+?)?\s*\}\}")
+random = random_module.Random()
+mod_random = random  # compat with name released in 0.8
+
+
+Sentinel = object()
+
+
+class Generator:
+    __config: Dict[str, Dict[Hashable, Any]] = {
+        "arguments": {},
+    }
+
+    _is_seeded = False
+    _global_seed = Sentinel
+
+    def __init__(self, **config: Dict) -> None:
+        self.providers: List["BaseProvider"] = []
+        self.__config = dict(list(self.__config.items()) + list(config.items()))
+        self.__random = random
+
+    def add_provider(self, provider: Union["BaseProvider", Type["BaseProvider"]]) -> None:
+        if isinstance(provider, type):
+            provider = provider(self)
+
+        self.providers.insert(0, provider)
+
+        for method_name in dir(provider):
+            # skip 'private' method
+            if method_name.startswith("_"):
+                continue
+
+            faker_function = getattr(provider, method_name)
+
+            if callable(faker_function):
+                # add all faker method to generator
+                self.set_formatter(method_name, faker_function)
+
+    def provider(self, name: str) -> Optional["BaseProvider"]:
+        try:
+            lst = [p for p in self.get_providers() if hasattr(p, "__provider__") and p.__provider__ == name.lower()]
+            return lst[0]
+        except IndexError:
+            return None
+
+    def get_providers(self) -> List["BaseProvider"]:
+        """Returns added providers."""
+        return self.providers
+
+    @property
+    def random(self) -> random_module.Random:
+        return self.__random
+
+    @random.setter
+    def random(self, value: random_module.Random) -> None:
+        self.__random = value
+
+    def seed_instance(self, seed: Optional[SeedType] = None) -> "Generator":
+        """Calls random.seed"""
+        if self.__random == random:
+            # create per-instance random obj when first time seed_instance() is
+            # called
+            self.__random = random_module.Random()
+        self.__random.seed(seed)
+        self._is_seeded = True
+        return self
+
+    @classmethod
+    def seed(cls, seed: Optional[SeedType] = None) -> None:
+        random.seed(seed)
+        cls._global_seed = seed
+        cls._is_seeded = True
+
+    def format(self, formatter: str, *args: Any, **kwargs: Any) -> str:
+        """
+        This is a secure way to make a fake from another Provider.
+        """
+        return self.get_formatter(formatter)(*args, **kwargs)
+
+    def get_formatter(self, formatter: str) -> Callable:
+        try:
+            return getattr(self, formatter)
+        except AttributeError:
+            if "locale" in self.__config:
+                msg = f'Unknown formatter {formatter!r} with locale {self.__config["locale"]!r}'
+            else:
+                raise AttributeError(f"Unknown formatter {formatter!r}")
+            raise AttributeError(msg)
+
+    def set_formatter(self, name: str, formatter: Callable) -> None:
+        """
+        This method adds a provider method to generator.
+        Override this method to add some decoration or logging stuff.
+        """
+        setattr(self, name, formatter)
+
+    def set_arguments(self, group: str, argument: str, value: Optional[Any] = None) -> None:
+        """
+        Creates an argument group, with an individual argument or a dictionary
+        of arguments. The argument groups is used to apply arguments to tokens,
+        when using the generator.parse() method. To further manage argument
+        groups, use get_arguments() and del_arguments() methods.
+
+        generator.set_arguments('small', 'max_value', 10)
+        generator.set_arguments('small', {'min_value': 5, 'max_value': 10})
+        """
+        if group not in self.__config["arguments"]:
+            self.__config["arguments"][group] = {}
+
+        if isinstance(argument, dict):
+            self.__config["arguments"][group] = argument
+        elif not isinstance(argument, str):
+            raise ValueError("Arguments must be either a string or dictionary")
+        else:
+            self.__config["arguments"][group][argument] = value
+
+    def get_arguments(self, group: str, argument: Optional[str] = None) -> Any:
+        """
+        Get the value of an argument configured within a argument group, or
+        the entire group as a dictionary. Used in conjunction with the
+        set_arguments() method.
+
+        generator.get_arguments('small', 'max_value')
+        generator.get_arguments('small')
+        """
+        if group in self.__config["arguments"] and argument:
+            result = self.__config["arguments"][group].get(argument)
+        else:
+            result = self.__config["arguments"].get(group)
+
+        return result
+
+    def del_arguments(self, group: str, argument: Optional[str] = None) -> Any:
+        """
+        Delete an argument from an argument group or the entire argument group.
+        Used in conjunction with the set_arguments() method.
+
+        generator.del_arguments('small')
+        generator.del_arguments('small', 'max_value')
+        """
+        if group in self.__config["arguments"]:
+            if argument:
+                result = self.__config["arguments"][group].pop(argument)
+            else:
+                result = self.__config["arguments"].pop(group)
+        else:
+            result = None
+
+        return result
+
+    def parse(self, text: str) -> str:
+        """
+        Replaces tokens like '{{ tokenName }}' or '{{tokenName}}' in a string with
+        the result from the token method call. Arguments can be parsed by using an
+        argument group. For more information on the use of argument groups, please
+        refer to the set_arguments() method.
+
+        Example:
+
+        generator.set_arguments('red_rgb', {'hue': 'red', 'color_format': 'rgb'})
+        generator.set_arguments('small', 'max_value', 10)
+
+        generator.parse('{{ color:red_rgb }} - {{ pyint:small }}')
+        """
+        return _re_token.sub(self.__format_token, text)
+
+    def __format_token(self, matches):
+        formatter, argument_group = list(matches.groups())
+        argument_group = argument_group.lstrip(":").strip() if argument_group else ""
+
+        if argument_group:
+            try:
+                arguments = self.__config["arguments"][argument_group]
+            except KeyError:
+                raise AttributeError(f"Unknown argument group {argument_group!r}")
+
+            formatted = str(self.format(formatter, **arguments))
+        else:
+            formatted = str(self.format(formatter))
+
+        return "".join(formatted)

.venv/lib/python3.12/site-packages/faker/providers/__init__.py

@@ -0,0 +1,742 @@
+import re
+import string
+
+from collections import OrderedDict
+from typing import Any, Collection, List, Optional, Sequence, TypeVar, Union
+
+from ..generator import Generator
+from ..typing import OrderedDictType
+from ..utils.distribution import choices_distribution, choices_distribution_unique
+
+_re_hash = re.compile(r"#")
+_re_perc = re.compile(r"%")
+_re_dol = re.compile(r"\$")
+_re_excl = re.compile(r"!")
+_re_at = re.compile(r"@")
+_re_qm = re.compile(r"\?")
+_re_cir = re.compile(r"\^")
+
+T = TypeVar("T")
+ElementsType = Union[Collection[T], OrderedDictType[T, float]]
+
+
+class BaseProvider:
+    __provider__ = "base"
+    __lang__: Optional[str] = None
+    __use_weighting__ = False
+
+    # Locales supported by Linux Mint from `/usr/share/i18n/SUPPORTED`
+    language_locale_codes = {
+        "aa": ("DJ", "ER", "ET"),
+        "af": ("ZA",),
+        "ak": ("GH",),
+        "am": ("ET",),
+        "an": ("ES",),
+        "apn": ("IN",),
+        "ar": (
+            "AE",
+            "BH",
+            "DJ",
+            "DZ",
+            "EG",
+            "EH",
+            "ER",
+            "IL",
+            "IN",
+            "IQ",
+            "JO",
+            "KM",
+            "KW",
+            "LB",
+            "LY",
+            "MA",
+            "MR",
+            "OM",
+            "PS",
+            "QA",
+            "SA",
+            "SD",
+            "SO",
+            "SS",
+            "SY",
+            "TD",
+            "TN",
+            "YE",
+        ),
+        "as": ("IN",),
+        "ast": ("ES",),
+        "ayc": ("PE",),
+        "az": ("AZ", "IN"),
+        "be": ("BY",),
+        "bem": ("ZM",),
+        "ber": ("DZ", "MA"),
+        "bg": ("BG",),
+        "bhb": ("IN",),
+        "bho": ("IN",),
+        "bn": ("BD", "IN"),
+        "bo": ("CN", "IN"),
+        "br": ("FR",),
+        "brx": ("IN",),
+        "bs": ("BA",),
+        "byn": ("ER",),
+        "ca": ("AD", "ES", "FR", "IT"),
+        "ce": ("RU",),
+        "ckb": ("IQ",),
+        "cmn": ("TW",),
+        "crh": ("UA",),
+        "cs": ("CZ",),
+        "csb": ("PL",),
+        "cv": ("RU",),
+        "cy": ("GB",),
+        "da": ("DK",),
+        "de": ("AT", "BE", "CH", "DE", "LI", "LU"),
+        "doi": ("IN",),
+        "dv": ("MV",),
+        "dz": ("BT",),
+        "el": ("GR", "CY"),
+        "en": (
+            "AG",
+            "AU",
+            "BD",
+            "BW",
+            "CA",
+            "DK",
+            "GB",
+            "HK",
+            "IE",
+            "IN",
+            "NG",
+            "NZ",
+            "PH",
+            "PK",
+            "SG",
+            "US",
+            "ZA",
+            "ZM",
+            "ZW",
+            "KE",
+        ),
+        "eo": ("US",),
+        "es": (
+            "AR",
+            "BO",
+            "CL",
+            "CO",
+            "CR",
+            "CU",
+            "DO",
+            "EC",
+            "ES",
+            "GT",
+            "HN",
+            "MX",
+            "NI",
+            "PA",
+            "PE",
+            "PR",
+            "PY",
+            "SV",
+            "US",
+            "UY",
+            "VE",
+        ),
+        "et": ("EE",),
+        "eu": ("ES", "FR"),
+        "fa": ("IR",),
+        "ff": ("SN",),
+        "fi": ("FI",),
+        "fil": ("PH",),
+        "fo": ("FO",),
+        "fr": ("CA", "CH", "FR", "LU"),
+        "fur": ("IT",),
+        "fy": ("NL", "DE"),
+        "ga": ("IE",),
+        "gd": ("GB",),
+        "gez": ("ER", "ET"),
+        "gl": ("ES",),
+        "gu": ("IN",),
+        "gv": ("GB",),
+        "ha": ("NG",),
+        "hak": ("TW",),
+        "he": ("IL",),
+        "hi": ("IN",),
+        "hne": ("IN",),
+        "hr": ("HR",),
+        "hsb": ("DE",),
+        "ht": ("HT",),
+        "hu": ("HU",),
+        "hy": ("AM",),
+        "ia": ("FR",),
+        "id": ("ID",),
+        "ig": ("NG",),
+        "ik": ("CA",),
+        "is": ("IS",),
+        "it": ("CH", "IT"),
+        "iu": ("CA",),
+        "iw": ("IL",),
+        "ja": ("JP",),
+        "ka": ("GE",),
+        "kk": ("KZ",),
+        "kl": ("GL",),
+        "km": ("KH",),
+        "kn": ("IN",),
+        "ko": ("KR",),
+        "kok": ("IN",),
+        "ks": ("IN",),
+        "ku": ("TR",),
+        "kw": ("GB",),
+        "ky": ("KG",),
+        "lb": ("LU",),
+        "lg": ("UG",),
+        "li": ("BE", "NL"),
+        "lij": ("IT",),
+        "ln": ("CD",),
+        "lo": ("LA",),
+        "lt": ("LT",),
+        "lv": ("LV",),
+        "lzh": ("TW",),
+        "mag": ("IN",),
+        "mai": ("IN",),
+        "mg": ("MG",),
+        "mhr": ("RU",),
+        "mi": ("NZ",),
+        "mk": ("MK",),
+        "ml": ("IN",),
+        "mn": ("MN",),
+        "mni": ("IN",),
+        "mr": ("IN",),
+        "ms": ("MY",),
+        "mt": ("MT",),
+        "my": ("MM",),
+        "nan": ("TW",),
+        "nb": ("NO",),
+        "nds": ("DE", "NL"),
+        "ne": ("NP",),
+        "nhn": ("MX",),
+        "niu": ("NU", "NZ"),
+        "nl": ("AW", "BE", "NL"),
+        "nn": ("NO",),
+        "nr": ("ZA",),
+        "nso": ("ZA",),
+        "oc": ("FR",),
+        "om": ("ET", "KE"),
+        "or": ("IN",),
+        "os": ("RU",),
+        "pa": ("IN", "PK"),
+        "pap": ("AN", "AW", "CW"),
+        "pl": ("PL",),
+        "ps": ("AF",),
+        "pt": ("BR", "PT"),
+        "quz": ("PE",),
+        "raj": ("IN",),
+        "ro": ("RO",),
+        "ru": ("RU", "UA"),
+        "rw": ("RW",),
+        "sa": ("IN",),
+        "sat": ("IN",),
+        "sc": ("IT",),
+        "sd": ("IN", "PK"),
+        "se": ("NO",),
+        "shs": ("CA",),
+        "si": ("LK",),
+        "sid": ("ET",),
+        "sk": ("SK",),
+        "sl": ("SI",),
+        "so": ("DJ", "ET", "KE", "SO"),
+        "sq": ("AL", "ML"),
+        "sr": ("ME", "RS"),
+        "ss": ("ZA",),
+        "st": ("ZA",),
+        "sv": ("FI", "SE"),
+        "sw": ("KE", "TZ"),
+        "szl": ("PL",),
+        "ta": ("IN", "LK"),
+        "tcy": ("IN",),
+        "te": ("IN",),
+        "tg": ("TJ",),
+        "th": ("TH",),
+        "the": ("NP",),
+        "ti": ("ER", "ET"),
+        "tig": ("ER",),
+        "tk": ("TM",),
+        "tl": ("PH",),
+        "tn": ("ZA",),
+        "tr": ("CY", "TR"),
+        "ts": ("ZA",),
+        "tt": ("RU",),
+        "ug": ("CN",),
+        "uk": ("UA",),
+        "unm": ("US",),
+        "ur": ("IN", "PK"),
+        "uz": ("UZ",),
+        "ve": ("ZA",),
+        "vi": ("VN",),
+        "wa": ("BE",),
+        "wae": ("CH",),
+        "wal": ("ET",),
+        "wo": ("SN",),
+        "xh": ("ZA",),
+        "yi": ("US",),
+        "yo": ("NG",),
+        "yue": ("HK",),
+        "zh": ("CN", "HK", "SG", "TW"),
+        "zu": ("ZA",),
+    }
+
+    def __init__(self, generator: Any) -> None:
+        """
+        Base class for fake data providers
+        :param generator: `Generator` instance
+        """
+        self.generator = generator
+
+    def locale(self) -> str:
+        """Generate a random underscored i18n locale code (e.g. en_US)."""
+
+        language_code = self.language_code()
+        return (
+            language_code
+            + "_"
+            + self.random_element(
+                BaseProvider.language_locale_codes[language_code],
+            )
+        )
+
+    def language_code(self) -> str:
+        """Generate a random i18n language code (e.g. en)."""
+
+        return self.random_element(BaseProvider.language_locale_codes.keys())
+
+    def random_int(self, min: int = 0, max: int = 9999, step: int = 1) -> int:
+        """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
+        """
+        return self.generator.random.randrange(min, max + 1, step)
+
+    def random_digit(self) -> int:
+        """Generate a random digit (0 to 9)."""
+
+        return self.generator.random.randint(0, 9)
+
+    def random_digit_not_null(self) -> int:
+        """Generate a random non-zero digit (1 to 9)."""
+
+        return self.generator.random.randint(1, 9)
+
+    def random_digit_above_two(self) -> int:
+        """Generate a random digit above value two (2 to 9)."""
+
+        return self.generator.random.randint(2, 9)
+
+    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.
+        """
+
+        if self.generator.random.randint(0, 1):
+            return self.generator.random.randint(0, 9)
+        else:
+            return ""
+
+    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.
+        """
+
+        if self.generator.random.randint(0, 1):
+            return self.generator.random.randint(1, 9)
+        else:
+            return ""
+
+    def random_number(self, digits: Optional[int] = None, fix_len: bool = False) -> 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
+        :sample: digits=3, fix_len=False
+        :sample: digits=3, fix_len=True
+        """
+        if digits is None:
+            digits = self.random_digit_not_null()
+        if digits < 0:
+            raise ValueError("The digit parameter must be greater than or equal to 0.")
+        if fix_len:
+            if digits > 0:
+                return self.generator.random.randint(pow(10, digits - 1), pow(10, digits) - 1)
+            else:
+                raise ValueError("A number of fixed length cannot have less than 1 digit in it.")
+        else:
+            return self.generator.random.randint(0, pow(10, digits) - 1)
+
+    def random_letter(self) -> str:
+        """Generate a random ASCII letter (a-z and A-Z)."""
+
+        return self.generator.random.choice(getattr(string, "letters", string.ascii_letters))
+
+    def random_letters(self, length: int = 16) -> Sequence[str]:
+        """Generate a list of random ASCII letters (a-z and A-Z) of the specified ``length``.
+
+        :sample: length=10
+        """
+        return self.random_choices(
+            getattr(string, "letters", string.ascii_letters),
+            length=length,
+        )
+
+    def random_lowercase_letter(self) -> str:
+        """Generate a random lowercase ASCII letter (a-z)."""
+
+        return self.generator.random.choice(string.ascii_lowercase)
+
+    def random_uppercase_letter(self) -> str:
+        """Generate a random uppercase ASCII letter (A-Z)."""
+
+        return self.generator.random.choice(string.ascii_uppercase)
+
+    def random_elements(
+        self,
+        elements: ElementsType[T] = ("a", "b", "c"),  # type: ignore[assignment]
+        length: Optional[int] = None,
+        unique: bool = False,
+        use_weighting: Optional[bool] = None,
+    ) -> 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([
+                    ("variable_1", 0.5),        # Generates "variable_1" 50% of the time
+                    ("variable_2", 0.2),        # Generates "variable_2" 20% of the time
+                    ("variable_3", 0.2),        # Generates "variable_3" 20% of the time
+                    ("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([
+                    ("variable_1", 0.5),
+                    ("variable_2", 0.2),
+                    ("variable_3", 0.2),
+                    ("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
+        :sample: elements=('a', 'b', 'c', 'd'), length=4, unique=True
+        :sample: elements=OrderedDict([
+                        ("a", 0.45),
+                        ("b", 0.35),
+                       ("c", 0.15),
+                       ("d", 0.05),
+                   ]), length=20, unique=False
+        :sample: elements=OrderedDict([
+                       ("a", 0.45),
+                       ("b", 0.35),
+                       ("c", 0.15),
+                       ("d", 0.05),
+                   ]), unique=True
+        """
+        use_weighting = use_weighting if use_weighting is not None else self.__use_weighting__
+
+        if isinstance(elements, dict) and not isinstance(elements, OrderedDict):
+            raise ValueError("Use OrderedDict only to avoid dependency on PYTHONHASHSEED (See #363).")
+
+        fn = choices_distribution_unique if unique else choices_distribution
+
+        if length is None:
+            length = self.generator.random.randint(1, len(elements))
+
+        if unique and length > len(elements):
+            raise ValueError("Sample length cannot be longer than the number of unique elements to pick from.")
+
+        if isinstance(elements, dict):
+            if not hasattr(elements, "_key_cache"):
+                elements._key_cache = tuple(elements.keys())  # type: ignore
+
+            choices = elements._key_cache  # type: ignore[attr-defined, union-attr]
+            probabilities = tuple(elements.values()) if use_weighting else None
+        else:
+            if unique:
+                # shortcut
+                return self.generator.random.sample(elements, length)
+            choices = elements
+            probabilities = None
+
+        return fn(
+            tuple(choices),
+            probabilities,
+            self.generator.random,
+            length=length,
+        )
+
+    def random_choices(
+        self,
+        elements: ElementsType[T] = ("a", "b", "c"),  # type: ignore[assignment]
+        length: Optional[int] = None,
+    ) -> 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([
+                     ("a", 0.45),
+                     ("b", 0.35),
+                     ("c", 0.15),
+                     ("d", 0.05),
+                 ])
+        :sample: elements=OrderedDict([
+                     ("a", 0.45),
+                     ("b", 0.35),
+                     ("c", 0.15),
+                     ("d", 0.05),
+                 ]), length=20
+        """
+        return self.random_elements(elements, length, unique=False)
+
+    def random_element(self, elements: ElementsType[T] = ("a", "b", "c")) -> T:  # type: ignore[assignment]
+        """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),
+                     ("b", 0.35),
+                     ("c", 0.15),
+                     ("d", 0.05),
+                 ])
+        """
+
+        return self.random_elements(elements, length=1)[0]
+
+    def random_sample(
+        self, elements: ElementsType[T] = ("a", "b", "c"), length: Optional[int] = None  # type: ignore[assignment]
+    ) -> 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
+        """
+        return self.random_elements(elements, length, unique=True)
+
+    def randomize_nb_elements(
+        self,
+        number: int = 10,
+        le: bool = False,
+        ge: bool = False,
+        min: Optional[int] = None,
+        max: Optional[int] = None,
+    ) -> 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``.
+          If ``True``, lower bound generation is capped at 100%.
+        - If a numerical value for ``min`` is provided, generated values less than ``min``
+          will be clamped at ``min``.
+        - If a numerical value for ``max`` is provided, generated values greater than
+          ``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
+        :sample: number=100, le=True
+        :sample: number=100, le=True, max=80
+        :sample: number=79, le=True, ge=True, min=80
+        """
+        if le and ge:
+            return number
+        _min = 100 if ge else 60
+        _max = 100 if le else 140
+        nb = int(number * self.generator.random.randint(_min, _max) / 100)
+        if min is not None and nb < min:
+            nb = min
+        if max is not None and nb > max:
+            nb = max
+        return nb
+
+    def numerify(self, text: 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).
+        - 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='!!! !!@ !@! !@@ @!! @!@ @@! @@@'
+        """
+        text = _re_hash.sub(lambda x: str(self.random_digit()), text)
+        text = _re_perc.sub(lambda x: str(self.random_digit_not_null()), text)
+        text = _re_dol.sub(lambda x: str(self.random_digit_above_two()), text)
+        text = _re_excl.sub(lambda x: str(self.random_digit_or_empty()), text)
+        text = _re_at.sub(lambda x: str(self.random_digit_not_null_or_empty()), text)
+        return text
+
+    def lexify(self, text: str = "????", letters: str = string.ascii_letters) -> str:
+        """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'
+        """
+        return _re_qm.sub(lambda x: self.random_element(letters), text)
+
+    def bothify(self, text: str = "## ??", letters: str = string.ascii_letters) -> 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).
+        - 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.
+        - 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'
+        :sample: text='Order: ##??-$'
+        """
+        return self.lexify(self.numerify(text), letters=letters)
+
+    def hexify(self, text: str = "^^^^", upper: bool = False) -> str:
+        """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
+        """
+        letters = string.hexdigits[:-6]
+        if upper:
+            letters = letters.upper()
+        return _re_cir.sub(lambda x: self.random_element(letters), text)
+
+
+class DynamicProvider(BaseProvider):
+    def __init__(
+        self,
+        provider_name: str,
+        elements: Optional[List] = None,
+        generator: Optional[Any] = None,
+    ):
+        """
+        A faker Provider capable of getting a list of elements to randomly select from,
+        instead of using the predefined list of elements which exist in the default providers in faker.
+
+        :param provider_name: Name of provider, which would translate into the function name e.g. faker.my_fun().
+        :param elements: List of values to randomly select from
+        :param generator: Generator object. If missing, the default Generator is used.
+
+        :example:
+        >>>from faker import Faker
+        >>>from faker.providers import DynamicProvider
+
+        >>>medical_professions_provider = DynamicProvider(
+        >>>     provider_name="medical_profession",
+        >>>     elements=["dr.", "doctor", "nurse", "surgeon", "clerk"],
+        >>>)
+        >>>fake = Faker()
+        >>>fake.add_provider(medical_professions_provider)
+
+        >>>fake.medical_profession()
+        "dr."
+
+        """
+
+        if not generator:
+            generator = Generator()
+        super().__init__(generator)
+        if provider_name.startswith("__"):
+            raise ValueError("Provider name cannot start with __ as it would be ignored by Faker")
+
+        self.provider_name = provider_name
+
+        self.elements = []
+        if elements:
+            self.elements = elements
+
+        setattr(self, provider_name, self.get_random_value)  # Add a method for the provider_name value
+
+    def add_element(self, element: str) -> None:
+        """Add new element."""
+        self.elements.append(element)
+
+    def get_random_value(self, use_weighting: bool = True) -> Any:
+        """Returns a random value for this provider.
+
+        :param use_weighting: boolean option to use weighting. Defaults to True
+        """
+        if not self.elements or len(self.elements) == 0:
+            raise ValueError("Elements should be a list of values the provider samples from")
+
+        return self.random_elements(self.elements, length=1, use_weighting=use_weighting)[0]

.venv/lib/python3.12/site-packages/faker/providers/address/__init__.py

@@ -0,0 +1,116 @@
+from .. import BaseProvider, ElementsType, date_time
+
+localized = True
+
+
+class Provider(BaseProvider):
+    city_suffixes: ElementsType[str] = ["Ville"]
+    street_suffixes: ElementsType[str] = ["Street"]
+    city_formats: ElementsType[str] = ("{{first_name}} {{city_suffix}}",)
+    street_name_formats: ElementsType[str] = ("{{last_name}} {{street_suffix}}",)
+    street_address_formats: ElementsType[str] = ("{{building_number}} {{street_name}}",)
+    address_formats: ElementsType[str] = ("{{street_address}} {{postcode}} {{city}}",)
+    building_number_formats: ElementsType[str] = ("##",)
+    postcode_formats: ElementsType[str] = ("#####",)
+    countries: ElementsType[str] = [country.name for country in date_time.Provider.countries]
+
+    ALPHA_2 = "alpha-2"
+    ALPHA_3 = "alpha-3"
+
+    alpha_2_country_codes: ElementsType[str] = [country.alpha_2_code for country in date_time.Provider.countries]
+    alpha_3_country_codes: ElementsType[str] = [country.alpha_3_code for country in date_time.Provider.countries]
+
+    def city_suffix(self) -> str:
+        """
+        :example: 'town'
+        """
+        return self.random_element(self.city_suffixes)
+
+    def street_suffix(self) -> str:
+        """
+        :example: 'Avenue'
+        """
+        return self.random_element(self.street_suffixes)
+
+    def building_number(self) -> str:
+        """
+        :example: '791'
+        """
+        return self.numerify(self.random_element(self.building_number_formats))
+
+    def city(self) -> str:
+        """
+        :example: 'Sashabury'
+        """
+        pattern: str = self.random_element(self.city_formats)
+        return self.generator.parse(pattern)
+
+    def street_name(self) -> str:
+        """
+        :example: 'Crist Parks'
+        """
+        pattern: str = self.random_element(self.street_name_formats)
+        return self.generator.parse(pattern)
+
+    def street_address(self) -> str:
+        """
+        :example: '791 Crist Parks'
+        """
+        pattern: str = self.random_element(self.street_address_formats)
+        return self.generator.parse(pattern)
+
+    def postcode(self) -> str:
+        """
+        :example: 86039-9874
+        """
+        return self.bothify(self.random_element(self.postcode_formats)).upper()
+
+    def address(self) -> str:
+        """
+        :example: '791 Crist Parks, Sashabury, IL 86039-9874'
+        """
+        pattern: str = self.random_element(self.address_formats)
+        return self.generator.parse(pattern)
+
+    def country(self) -> str:
+        """
+        :sample:
+        """
+        return self.random_element(self.countries)
+
+    def country_code(self, representation: str = ALPHA_2) -> str:
+        """
+        :sample:
+        :sample: representation='alpha-2'
+        :sample: representation='alpha-3'
+        """
+        if representation == self.ALPHA_2:
+            return self.random_element(self.alpha_2_country_codes)
+        elif representation == self.ALPHA_3:
+            return self.random_element(self.alpha_3_country_codes)
+        else:
+            raise ValueError("`representation` must be one of `alpha-2` or `alpha-3`.")
+
+    def current_country_code(self) -> str:
+        """
+        :sample:
+        """
+        try:
+            return self.__lang__.split("_")[1]  # type: ignore
+        except IndexError:
+            raise AttributeError("Country code cannot be determined from locale")
+
+    def current_country(self) -> str:
+        """
+        :sample:
+        """
+        current_country_code = self.current_country_code()
+        current_country = [
+            country.name for country in date_time.Provider.countries if country.alpha_2_code == current_country_code
+        ]
+        if len(current_country) == 1:
+            return current_country[0]  # type: ignore
+        elif len(current_country) > 1:
+            raise ValueError(f"Ambiguous country for country code {current_country_code}: {current_country}")
+        else:
+            raise ValueError(f"No appropriate country for country code {current_country_code}")

.venv/lib/python3.12/site-packages/faker/providers/address/ar_DZ/__init__.py

@@ -0,0 +1,347 @@
+from typing import Tuple
+
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    """Address provider for ar_DZ locale."""
+
+    # Source: https://ar.wikipedia.org/wiki/ولايات_الجزائر
+    wilayas: Tuple[str, ...] = (
+        "أدرار",
+        "الشلف",
+        "الأغواط",
+        "أم البواقي",
+        "باتنة",
+        "بجاية",
+        "بسكرة",
+        "بشار",
+        "البليدة",
+        "البويرة",
+        "تمنراست",
+        "تبسة",
+        "تلمسان",
+        "تيارت",
+        "تيزي وزو",
+        "الجزائر",
+        "الجلفة",
+        "جيجل",
+        "سطيف",
+        "سعيدة",
+        "سكيكدة",
+        "سيدي بلعباس",
+        "عنابة",
+        "قالمة",
+        "قسنطينة",
+        "المدية",
+        "مستغانم",
+        "المسيلة",
+        "معسكر",
+        "ورقلة",
+        "وهران",
+        "البيض",
+        "إليزي",
+        "برج بوعريريج",
+        "بومرداس",
+        "الطارف",
+        "تندوف",
+        "تيسمسيلت",
+        "الوادي",
+        "خنشلة",
+        "سوق أهراس",
+        "تيبازة",
+        "ميلة",
+        "عين الدفلى",
+        "النعامة",
+        "عين تموشنت",
+        "غرداية",
+        "غليزان",
+        "تيميمون",
+        "برج باجي مختار",
+        "أولاد جلال",
+        "بني عباس",
+        "عين صالح",
+        "عين قزام",
+        "تقرت",
+        "جانت",
+        "المغير",
+        "المنيعة",
+    )
+
+    # Source: https://github.com/othmanus/algeria-cities
+    cities: Tuple[str, ...] = (
+        # Wilaya 01 - أدرار
+        "أدرار",
+        "رقان",
+        "أولف",
+        "تيميمون",
+        # Wilaya 02 - الشلف
+        "الشلف",
+        "تنس",
+        "بوقادير",
+        # Wilaya 03 - الأغواط
+        "الأغواط",
+        "أفلو",
+        "عين ماضي",
+        # Wilaya 04 - أم البواقي
+        "أم البواقي",
+        "عين مليلة",
+        "عين البيضاء",
+        # Wilaya 05 - باتنة
+        "باتنة",
+        "بريكة",
+        "عين التوتة",
+        "أريس",
+        "نقاوس",
+        # Wilaya 06 - بجاية
+        "بجاية",
+        "أقبو",
+        "خراطة",
+        "تاكسلانت",
+        "أميزور",
+        # Wilaya 07 - بسكرة
+        "بسكرة",
+        "طولقة",
+        "سيدي عقبة",
+        "زريبة الوادي",
+        # Wilaya 08 - بشار
+        "بشار",
+        "تاغيت",
+        "القنادسة",
+        # Wilaya 09 - البليدة
+        "البليدة",
+        "بوفاريك",
+        "الأربعاء",
+        "بوعينان",
+        # Wilaya 10 - البويرة
+        "البويرة",
+        "سور الغزلان",
+        "عين بسام",
+        # Wilaya 11 - تمنراست
+        "تمنراست",
+        "أبلسة",
+        # Wilaya 12 - تبسة
+        "تبسة",
+        "بئر العاتر",
+        "الونزة",
+        # Wilaya 13 - تلمسان
+        "تلمسان",
+        "مغنية",
+        "الغزوات",
+        "ندرومة",
+        "مرسى بن مهيدي",
+        # Wilaya 14 - تيارت
+        "تيارت",
+        "السوقر",
+        "فرندة",
+        "تاقدمت",
+        # Wilaya 15 - تيزي وزو
+        "تيزي وزو",
+        "ذراع بن خدة",
+        "أزفون",
+        "بوغني",
+        "تيقزيرت",
+        # Wilaya 16 - الجزائر
+        "الجزائر الوسطى",
+        "باب الوادي",
+        "القصبة",
+        "سيدي امحمد",
+        "حسين داي",
+        "القبة",
+        "الحراش",
+        "الرويبة",
+        "زرالدة",
+        "بئر مراد رايس",
+        "بوزريعة",
+        "الشراقة",
+        "الدرارية",
+        "باب الزوار",
+        "برج الكيفان",
+        "الدار البيضاء",
+        "عين طاية",
+        # Wilaya 17 - الجلفة
+        "الجلفة",
+        "مسعد",
+        "عين وسارة",
+        "حاسي بحبح",
+        # Wilaya 18 - جيجل
+        "جيجل",
+        "الطاهير",
+        "الميلية",
+        "زيامة منصورية",
+        # Wilaya 19 - سطيف
+        "سطيف",
+        "العلمة",
+        "جميلة",
+        "عين أرنات",
+        "قجال",
+        # Wilaya 20 - سعيدة
+        "سعيدة",
+        "عين الحجر",
+        # Wilaya 21 - سكيكدة
+        "سكيكدة",
+        "عزابة",
+        "الحروش",
+        "القل",
+        # Wilaya 22 - سيدي بلعباس
+        "سيدي بلعباس",
+        "عين البرد",
+        "مرحوم",
+        "تلموني",
+        # Wilaya 23 - عنابة
+        "عنابة",
+        "البوني",
+        "عين الباردة",
+        "سيدي عمار",
+        # Wilaya 24 - قالمة
+        "قالمة",
+        "بومهرة أحمد",
+        "حمام النبايل",
+        # Wilaya 25 - قسنطينة
+        "قسنطينة",
+        "الخروب",
+        "ديدوش مراد",
+        "زيغود يوسف",
+        "عين عبيد",
+        # Wilaya 26 - المدية
+        "المدية",
+        "قصر البخاري",
+        "البرواقية",
+        "بوغار",
+        # Wilaya 27 - مستغانم
+        "مستغانم",
+        "سيدي علي",
+        "عين تادلس",
+        "مزغران",
+        # Wilaya 28 - المسيلة
+        "المسيلة",
+        "بوسعادة",
+        "سيدي عيسى",
+        "عين الملح",
+        # Wilaya 29 - معسكر
+        "معسكر",
+        "تيغنيف",
+        "بوحنيفية",
+        "سيق",
+        # Wilaya 30 - ورقلة
+        "ورقلة",
+        "حاسي مسعود",
+        "عين البيضاء",
+        # Wilaya 31 - وهران
+        "وهران",
+        "أرزيو",
+        "عين الترك",
+        "بئر الجير",
+        "مرسى الحجاج",
+        "السانية",
+        # Wilaya 32 - البيض
+        "البيض",
+        "بريزينة",
+        # Wilaya 33 - إليزي
+        "إيليزي",
+        "إن أمناس",
+        # Wilaya 34 - برج بوعريريج
+        "برج بوعريرج",
+        "رأس الوادي",
+        "ثنية النصر",
+        # Wilaya 35 - بومرداس
+        "بومرداس",
+        "خميس الخشنة",
+        "برج منايل",
+        "دلس",
+        # Wilaya 36 - الطارف
+        "الطارف",
+        "القالة",
+        "بن مهيدي",
+        # Wilaya 37 - تندوف
+        "تندوف",
+        # Wilaya 38 - تيسمسيلت
+        "تيسمسيلت",
+        "خميستي",
+        # Wilaya 39 - الوادي
+        "الوادي",
+        "قمار",
+        "حاسي خليفة",
+        "الرقيبة",
+        # Wilaya 40 - خنشلة
+        "خنشلة",
+        "بابار",
+        # Wilaya 41 - سوق أهراس
+        "سوق أهراس",
+        "مداوروش",
+        "سدراتة",
+        # Wilaya 42 - تيبازة
+        "تيبازة",
+        "شرشال",
+        "بواسماعيل",
+        "القليعة",
+        # Wilaya 43 - ميلة
+        "ميلة",
+        "فرجيوة",
+        "شلغوم العيد",
+        # Wilaya 44 - عين الدفلى
+        "عين الدفلى",
+        "خميس مليانة",
+        "العطاف",
+        "مليانة",
+        # Wilaya 45 - النعامة
+        "النعامة",
+        "المشرية",
+        "عين الصفراء",
+        # Wilaya 46 - عين تموشنت
+        "عين تموشنت",
+        "بني صاف",
+        "حمام بوحجر",
+        # Wilaya 47 - غرداية
+        "غرداية",
+        "القرارة",
+        "متليلي",
+        "العطف",
+        # Wilaya 48 - غليزان
+        "غليزان",
+        "مازونة",
+        "عمي موسى",
+        # New wilayas (49–58)
+        "تيميمون",
+        "برج باجي مختار",
+        "أولاد جلال",
+        "بني عباس",
+        "عين صالح",
+        "عين قزام",
+        "تقرت",
+        "جانت",
+        "المغير",
+        "المنيعة",
+    )
+
+    street_prefixes: Tuple[str, ...] = ("شارع", "نهج", "طريق", "حي", "زنقة", "دوار", "بلدية")
+
+    building_number_formats: Tuple[str, ...] = ("#", "##", "###")
+
+    # Source: https://github.com/othmanus/algeria-cities
+    postcode_formats: Tuple[str, ...] = tuple(f"{i:02d}###" for i in range(1, 49))
+
+    street_name_formats: Tuple[str, ...] = (
+        "{{street_prefix}} {{last_name}}",
+        "{{street_prefix}} {{first_name}} {{last_name}}",
+    )
+
+    street_address_formats: Tuple[str, ...] = ("{{building_number}} {{street_name}}",)
+
+    address_formats: Tuple[str, ...] = (
+        "{{street_address}} {{city}}",
+        "{{street_address}} - {{city}}",
+        "{{street_address}} {{city}} {{wilaya}}",
+        "{{street_address}} {{city}} - {{wilaya}}",
+    )
+
+    def street_prefix(self) -> str:
+        return self.random_element(self.street_prefixes)
+
+    def city(self) -> str:
+        return self.random_element(self.cities)
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.wilayas)
+
+    wilaya = administrative_unit

.venv/lib/python3.12/site-packages/faker/providers/address/az_AZ/__init__.py

@@ -0,0 +1,691 @@
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_formats = ("{{first_name}}",)
+    city_suffixes = ("şəhəri", "ş.")
+    street_suffixes = ("küçəsi", "küç.", "prospekti", "pr.")
+    village_suffixes = ("kəndi", "k.")
+    district_suffixes = ("rayonu", "ray.")
+    settlement_suffixes = ("qəsəbəsi", "qəs.")
+
+    building_number_formats = ("#",)
+    house_number_formats = ("#", "##", "###")
+    address_formats = (
+        "{{city}} {{city_suffix }}, {{street_name}} {{street_suffix}}, b. {{building_number}}, m. {{house_number}}",
+        "{{district}} {{district_suffix }}, {{street_name}} {{street_suffix}}, b. {{building_number}},"
+        " m. {{house_number}}",
+        "{{district}} {{district_suffix }}, {{village}} {{village_suffix}}, {{street_name}} {{street_suffix}}",
+        "{{district}} {{district_suffix }}, {{settlement}} {{settlement_suffix}}, {{street_name}} {{street_suffix}},"
+        " b. {{building_number}}, m. {{house_number}}",
+    )
+    street_name_formats = ("{{street}}",)
+    cities = [
+        "Bakı",
+        "Gəncə",
+        "Naxçıvan",
+        "Xankəndi",
+        "Lənkəran",
+        "Mingəçevir",
+        "Naftalan",
+        "Sumqayıt",
+        "Şəki",
+        "Şirvan",
+        "Yevlax",
+    ]
+    countries = [
+        "Abxaziya",
+        "Akrotiri və Dekeliya",
+        "Aland adaları",
+        "Albaniya",
+        "Almaniya",
+        "Amerika Samoası",
+        "Andorra Knyazlığı",
+        "Angilya",
+        "Anqola",
+        "Antiqua və Barbuda",
+        "Argentina Respublikası",
+        "Aruba",
+        "Avstraliya",
+        "Avstriya",
+        "Azərbaycan",
+        "Baham adaları",
+        "Banqladeş",
+        "Barbados",
+        "Belçika",
+        "Beliz",
+        "Belarus",
+        "Benin",
+        "Bermud adaları",
+        "Birləşmiş Ərəb Əmirlikləri",
+        "ABŞ",
+        "Boliviya",
+        "Bolqarıstan",
+        "Bosniya və Herseqovina",
+        "Botsvana",
+        "Böyük Britaniya",
+        "Braziliya",
+        "Bruney",
+        "Burkina",
+        "Burundi",
+        "Butan",
+        "Bəhreyn",
+        "Cersi",
+        "Cəbəllütariq",
+        "Cənubi Afrika Respublikası",
+        "Cənubi Sudan",
+        "Cənubi Koreya",
+        "Cibuti",
+        "Çad",
+        "Çexiya",
+        "Monteneqro",
+        "Çili",
+        "Çin",
+        "Danimarka",
+        "Dominika",
+        "Dominikan",
+        "Efiopiya",
+        "Ekvador",
+        "Ekvatorial",
+        "Eritreya",
+        "Ermənistan",
+        "Estoniya",
+        "Əfqanıstan",
+        "Əlcəzair",
+        "Farer adaları",
+        "Fələstin",
+        "Fici",
+        "Fil Dişi Sahili",
+        "Filippin",
+        "Finlandiya",
+        "Folklend adaları",
+        "Fransa",
+        "Fransa Polineziyası",
+        "Gernsi",
+        "Gürcüstan",
+        "Haiti",
+        "Hindistan",
+        "Honduras",
+        "Honkonq",
+        "Xorvatiya",
+        "İndoneziya",
+        "İordaniya",
+        "İraq",
+        "İran",
+        "İrlandiya",
+        "İslandiya",
+        "İspaniya",
+        "İsrail",
+        "İsveç",
+        "İsveçrə",
+        "İtaliya",
+        "Kabo-Verde",
+        "Kamboca",
+        "Kamerun",
+        "Kanada",
+        "Kayman adaları",
+        "Keniya",
+        "Kipr",
+        "Kiribati",
+        "Kokos adaları",
+        "Kolumbiya",
+        "Komor adaları",
+        "Konqo Respublikası",
+        "Konqo Demokratik Respublikası",
+        "Kosovo",
+        "Kosta-Rika",
+        "Kuba",
+        "Kuk adaları",
+        "Küveyt",
+        "Qabon",
+        "Qambiya",
+        "Qana",
+        "Qətər",
+        "Qayana",
+        "Qazaxıstan",
+        "Qərbi Saxara",
+        "Qırğızıstan",
+        "Qrenada",
+        "Qrenlandiya",
+        "Quam",
+        "Qvatemala",
+        "Qvineya",
+        "Qvineya-Bisau",
+        "Laos",
+        "Latviya",
+        "Lesoto",
+        "Liberiya",
+        "Litva",
+        "Livan",
+        "Liviya",
+        "Lixtenşteyn",
+        "Lüksemburq",
+        "Macarıstan",
+        "Madaqaskar",
+        "Makao",
+        "Şimali Makedoniya",
+        "Malavi",
+        "Malayziya",
+        "Maldiv adaları",
+        "Mali",
+        "Malta",
+        "Marşall adaları",
+        "Mavriki",
+        "Mavritaniya",
+        "Mayotta",
+        "Meksika",
+        "Men adası",
+        "Mərakeş",
+        "Mərkəzi Afrika Respublikası",
+        "Mikroneziya",
+        "Milad adası",
+        "Misir",
+        "Myanma",
+        "Moldova",
+        "Monako",
+        "Monqolustan",
+        "Montserrat",
+        "Mozambik",
+        "Müqəddəs Yelena adası",
+        "Namibiya",
+        "Nauru",
+        "Nepal",
+        "Niderland",
+        "Niger",
+        "Nigeriya",
+        "Nikaraqua",
+        "Norveç",
+        "Oman",
+        "Özbəkistan",
+        "Pakistan",
+        "Palau",
+        "Panama",
+        "Papua",
+        "Paraqvay",
+        "Peru",
+        "Pitkern adaları",
+        "Polşa",
+        "Portuqaliya",
+        "Puerto-Riko",
+        "Ruanda",
+        "Rumıniya",
+        "Rusiya",
+        "Salvador",
+        "Samoa",
+        "San-Marino",
+        "San-Tome və Prinsipi",
+        "Seneqal",
+        "Sen-Bartelemi",
+        "Sent-Kits və Nevis",
+        "Sent-Lüsiya",
+        "Sen-Marten",
+        "Sen-Pyer və Mikelon",
+        "Sent-Vinsent və Qrenadin",
+        "Serbiya",
+        "Seyşel adaları",
+        "Səudiyyə Ərəbistanı",
+        "Sinqapur",
+        "Slovakiya",
+        "Sloveniya",
+        "Solomon adaları",
+        "Somali",
+        "Somalilend",
+        "Sudan",
+        "Surinam",
+        "Suriya",
+        "Esvatini",
+        "Syerra-Leone",
+        "Şərqi Timor",
+        "Şimali Kipr Türk Respublikası",
+        "Şimali Koreya",
+        "Şimali Marian adaları",
+        "Şri-Lanka",
+        "Tacikistan",
+        "Tanzaniya",
+        "Tailand",
+        "Tonqa",
+        "Toqo",
+        "Trinidad və Tobaqo",
+        "Tunis",
+        "Tuvalu",
+        "Türkiyə",
+        "Türkmənistan",
+        "Ukrayna",
+        "Uqanda",
+        "Uruqvay",
+        "Vanuatu",
+        "Vatikan",
+        "Venesuela",
+        "Vyetnam",
+        "Yamayka",
+        "Yaponiya",
+        "Yeni Kaledoniya",
+        "Yeni Zelandiya",
+        "Yəmən",
+        "Yunanıstan",
+        "Zambiya",
+        "Zimbabve",
+    ]
+    districts = [
+        "Abşeron",
+        "Ağcabədi",
+        "Ağdam",
+        "Ağdaş",
+        "Ağstafa",
+        "Ağsu",
+        "Astara",
+        "Babək",
+        "Balakən",
+        "Beyləqan",
+        "Bərdə",
+        "Biləsuvar",
+        "Cəbrayıl",
+        "Cəlilabad",
+        "Culfa",
+        "Daşkəsən",
+        "Füzuli",
+        "Gədəbəy",
+        "Goranboy",
+        "Göyçay",
+        "Göygöl",
+        "Hacıqabul",
+        "Xaçmaz",
+        "Xızı",
+        "Xocalı",
+        "Xocavənd",
+        "İmişli",
+        "İsmayıllı",
+        "Kəlbəcər",
+        "Kəngərli",
+        "Kürdəmir",
+        "Qax",
+        "Qazax",
+        "Qəbələ",
+        "Qobustan",
+        "Quba",
+        "Qubadlı",
+        "Qusar",
+        "Laçın",
+        "Lerik",
+        "Lənkəran",
+        "Masallı",
+        "Neftçala",
+        "Oğuz",
+        "Ordubad*",
+        "Saatlı",
+        "Sabirabad",
+        "Salyan",
+        "Samux",
+        "Sədərək",
+        "Siyəzən",
+        "Şabran",
+        "Şahbuz",
+        "Şamaxı",
+        "Şəki",
+        "Şəmkir",
+        "Şərur",
+        "Şuşa",
+        "Tərtər",
+        "Tovuz",
+        "Ucar",
+        "Yardımlı",
+        "Yevlax",
+        "Zaqatala",
+        "Zəngilan",
+        "Zərdab",
+    ]
+    settlements = [
+        "Ləki",
+        "Nehrəm",
+        "Soyuqbulaq",
+        "Şəkərli",
+        "Cəhri",
+        "Qarayazi",
+        "Həzi asalanov",
+        "Poylu",
+        "Ceyrançöl",
+        "Saloğlu",
+        "Vurğun",
+        "Qəhramanli",
+        "Yuxari aran",
+        "Mayak",
+        "Milabad",
+        "Örənqala",
+        "Baharabad",
+        "Günəş",
+        "Orconikidze",
+        "Digah",
+        "Güzdək",
+        "Hökməli",
+        "Qobu",
+        "Mehdiabad",
+        "Saray",
+        "Taxtakörpü",
+        "Hindarx",
+        "Şərq",
+        "Sarisu",
+        "Mil",
+        "Türklər",
+        "Bahar",
+        "Babək",
+        "Keşlə",
+        "Qabaqçöl",
+        "Xindiristan",
+        "Bənövşələr",
+        "Birinci alibəyli",
+        "Birinci baharli",
+        "Birinci dördyol",
+        "Birinci quzanli",
+        "İkinci alibəyli",
+        "İkinci baharli",
+        "İkinci dördyol",
+        "İmamqulubəyli",
+        "Qasimbəyli",
+        "Səfərli",
+        "Təzəkənd",
+        "Ergi",
+        "Yeni ergi",
+        "Aşaği qəsil kəndi",
+        "Orta qəsil kəndi",
+        "Türyançay",
+        "Yuxari qəsil kəndi",
+        "Birinci zobucuq",
+        "İkinci zobucuq",
+        "Üçüncü zobucuq",
+        "Dördüncü zobucuq",
+        "Beşinci zobucuq",
+        "Fin",
+        "Horadiz",
+        "Qayidiş 2",
+        "Hacikənd",
+        "Yuxari ağcakənd",
+        "Qizilhacili",
+        "Goran",
+        "Aşaği ağcakənd",
+        "Qazanbulaq",
+        "Kürəkçay",
+        "Ayaq qərvənd",
+        "Quzanli",
+        "Navahi",
+        "Pirsaat",
+        "Muğan",
+        "Padar",
+        "Navahi",
+        "Vətəgə",
+        "Bəhrəmtəpə",
+        "Lahic",
+        "Basqal",
+        "Şəfəq",
+        "Yeni mil",
+        "Xocahəsən",
+        "Sulutəpə",
+        "Biləcəri",
+        "Binəqədi",
+        "28 may",
+        "Rəsulzadə",
+        "Qumlaq",
+        "Xələfli",
+        "Xudafərin",
+        "Mahmudlu",
+        "Novoqolovka",
+        "Alunitdağ",
+        "Quşçu körpüsü",
+        "Daşkəsən",
+        "Quşçu",
+        "Yuxari daşkəsən",
+        "1 nömrəli qayidiş",
+        "2 nömrəli qayidiş",
+    ]
+    streets = [
+        "A.AĞAYEV",
+        "A.M.CÜMƏ",
+        "TƏBRİZ",
+        "XALİQ ABBASOV",
+        "İSLAM ABIŞOV",
+        "HEYDƏR ƏLİYEV",
+        "XƏTAİ",
+        "GÖL ƏTRAFI",
+        "Z.XƏLİL",
+        "2-Cİ SÜLH",
+        "Q.PİRİMOV",
+        "ASİF MƏMMƏDOV",
+        "R.HACIYEV",
+        "FƏXRƏDDİN ƏSƏDOV",
+        "K.MARKS",
+        "OKTAY KƏRİMOV",
+        "Z.KAZIMZADƏ",
+        "HƏSƏNOĞLU",
+        "KAVEROÇKİN",
+        "P.ÇAYKOVSKİ",
+        "HÜSEYN ARİF",
+        "HACI MURAD",
+        "BAKI-BATUMİ",
+        "NEMƏT QULİYEV",
+        "R.AXUNDOV",
+        "AKAD.H.ƏLİYEV",
+        "RƏHİM ŞIXƏLİYEV",
+        "YUSİFZADƏ",
+        "E.QOCAYEV",
+        "TARZƏN H.MƏMMƏDOV",
+        "İ.HİDAYƏTZADƏ",
+        "T.ƏLİYEV",
+        "MƏMMƏD ARAZ",
+        "V.PLOTNİKOV",
+        "Ə.ORUCƏLİYEV",
+        "Z.BÜNYADOV",
+        "İ.DADAŞOV",
+        "ƏLƏSGƏR QAYIBOV",
+        "M.ARİF",
+        "M.QASQAY",
+        "Ə.ƏBDÜLRƏHİMOV",
+        "İZZƏT HƏMİDOV",
+        "AZADLIQ",
+        "ARİF HEYDƏROV",
+        "N.SÜLEYMANOV",
+        "ŞAHİN MUSTAFAYEV",
+        "Ə.VAHİD",
+        "Ü.BÜNYADZADƏ",
+        "NAZİM HACIYEV",
+        "24-CÜ KORPÜ",
+        "1-Cİ MƏDƏN",
+        "Y.HÜSEYNOV",
+        "22-Cİ DAĞLIQ",
+        "SÜD FERMASI",
+        "ÇAPAYEV",
+        "E. NƏCƏFOV",
+        "FAİQ RÜSTƏMOV",
+        "28 MAY",
+        "ZABİTLƏR EVİ",
+        "S.S. AXUNDOV",
+        "GƏNCLƏR DOSTLUĞU",
+        "H.SULTANOV",
+        "ƏHMƏD QASIMOV",
+        "XURŞUD AĞAYEV",
+        "NATƏVAN",
+        "YENİ MASSİV",
+        "MƏLİK ASLANOV KÜÇƏSİ,",
+        "VİDADİ",
+        "8 MART",
+        "İ.HACIYEV",
+        "Y. HƏSƏNOV",
+    ]
+    villages = [
+        "Kələki",
+        "Binələr",
+        "Davudlu",
+        "Birinci aral",
+        "İkinci aral",
+        "Cardam",
+        "Qaradeyin",
+        "Qarağan şixlar",
+        "Qarağan sədi",
+        "Qəribli",
+        "Qolqəti",
+        "Mürsəl",
+        "Şordəhnə",
+        "Tofiqi",
+        "Yenicə",
+        "Ərəbocaği",
+        "Hapitli",
+        "Ovçulu",
+        "Şəkili",
+        "Yuxari ağcayazi",
+        "Aşaği ağcayazi",
+        "Yuxari ləki",
+        "Düzqişlaq",
+        "Kolayir",
+        "Koçvəlili",
+        "Xətai",
+        "Yenigün",
+        "Qaçaq kərəm",
+        "Poylu",
+        "Tatli",
+        "Yaradullu",
+        "Xilxina",
+        "Mollacəfərli",
+        "Ağgöl",
+        "Aşaği göycəli",
+        "Aşaği kəsəmən",
+        "Böyük kəsik",
+        "Dağ kəsəmən",
+        "Eynalli",
+        "Göycəli",
+        "Həsənsu",
+        "Kolxələfli",
+        "Koçəsgər",
+        "Köhnəqişlaq",
+        "Qarahəsənli",
+        "Soyuqbulaqlar",
+        "Qiraq kəsəmən",
+        "Didivar",
+        "Muğanli",
+        "Pirili",
+        "Sadiqli",
+        "Uzunoba",
+        "Qaraməmmədli",
+        "Navahi",
+        "Ülgüc",
+        "Ərəbmehdibəy",
+        "Dədəli",
+        "Qasimbəyli",
+        "Ərəbsarvan",
+        "Haciqədirli",
+        "Göydəlləkli",
+        "Ərəbuşaği",
+        "Ağalarbəyli",
+        "Maşadqanli",
+        "Aratli curuğlu",
+        "Keşdiməz",
+        "Bozavand",
+        "Ağarx",
+        "Qarabağli",
+        "Xanbulaq",
+        "Kəndaxan",
+        "Yenilik",
+        "Kövlüc",
+        "Elabad",
+        "Yenikənd",
+        "Hingar",
+        "Girdə",
+        "Gursulu",
+        "Qaraqoyunlu",
+        "Musabəyli",
+        "İlxiçi",
+        "Hacisəmədli",
+        "Qəşəd",
+        "Kəndoba",
+        "Cəfərli",
+        "Haciuşaği",
+        "Cəlayir",
+        "Abasxanli",
+        "Kalva",
+        "Suraxani",
+        "Dilman",
+        "Haciman",
+        "Xatman",
+        "Növcü",
+        "Axundlu",
+        "Məlikçobanli",
+    ]
+
+    def house_number(self) -> str:
+        """
+        :example: 'm. 49'
+        """
+        return self.numerify(self.random_element(self.house_number_formats))
+
+    def city(self) -> str:
+        """
+        :example: 'Xankəndi'
+        """
+        return self.random_element(self.cities)
+
+    def city_suffix(self) -> str:
+        """
+        :example: 'ş.'
+        """
+        return self.random_element(self.city_suffixes)
+
+    def street(self) -> str:
+        """
+        :example: 'A.AĞAYEV'
+        """
+        return self.random_element(self.streets)
+
+    def street_suffix(self) -> str:
+        """
+        :example: 'küç.'
+        """
+        return self.random_element(self.street_suffixes)
+
+    def village(self) -> str:
+        """
+        :example: 'Didivar'
+        """
+        return self.random_element(self.villages)
+
+    def village_suffix(self) -> str:
+        """
+        :example: 'k.'
+        """
+        return self.random_element(self.village_suffixes)
+
+    def district(self) -> str:
+        """
+        :example: 'Babək'
+        """
+        return self.random_element(self.districts)
+
+    def district_suffix(self) -> str:
+        """
+        :example: 'r.'
+        """
+        return self.random_element(self.district_suffixes)
+
+    def settlement(self) -> str:
+        """
+        :example: 'Horadiz'
+        """
+        return self.random_element(self.settlements)
+
+    def settlement_suffix(self) -> str:
+        """
+        :example: 'qəs.'
+        """
+        return self.random_element(self.settlement_suffixes)
+
+    def administrative_unit(self) -> str:
+        """
+        :example: 'Xankəndi'
+        """
+        return self.random_element(self.districts + self.cities)
+
+    def postcode(self) -> str:
+        """
+        :example: 'AZ1027'
+        """
+        index = self.generator.random.randint(900, 6600)
+        return "AZ%04d" % index if index > 999 else "AZ0%03d" % index
+
+    def postalcode(self) -> str:
+        return self.postcode()

.venv/lib/python3.12/site-packages/faker/providers/address/bn_BD/__init__.py

@@ -0,0 +1,547 @@
+from faker.providers.person.bn_BD import translate_to_bengali_digits
+
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    area_names = (
+        "আলি",
+        "আলম",
+        "অভয়",
+        "আনোয়ার",
+        "ব্রাহ্মণ",
+        "বটিয়া",
+        "বাঘার",
+        "বেগম",
+        "বিজয়",
+        "বন্দর",
+        "বালিয়া",
+        "বাজিত",
+        "বাকের",
+        "বোরহান",
+        "বকশী",
+        "বদর",
+        "বিরাম",
+        "বিশ্বনাথ",
+        "চৌদ্দ",
+        "চিতল",
+        "দাউদ",
+        "দৌলত",
+        "দেব",
+        "দেবী",
+        "ইসলাম",
+        "ফুল",
+        "ফকির",
+        "ফটিক",
+        "গোপাল",
+        "গৌর",
+        "হাজী",
+        "হরিরাম",
+        "হোসেন",
+        "হাকিম",
+        "জীবন",
+        "জগন্নাথ",
+        "কুমার",
+        "কালী",
+        "কেশব",
+        "কুতুব",
+        "কবির",
+        "কালিয়া",
+        "করিম",
+        "কাজী",
+        "কমল",
+        "লাল",
+        "মুরাদ",
+        "মনোহর",
+        "মির",
+        "মহেশ",
+        "মোড়ল",
+        "মোল্লা",
+        "মোহাম্মদ",
+        "মনিরাম",
+        "মানিক",
+        "মির্জা",
+        "মধু",
+        "মোহন",
+        "মহাদেব",
+        "মাধব",
+        "নাসির",
+        "নড়িয়া",
+        "নাজির",
+        "নালিতা",
+        "নন্দী",
+        "ওসমানী",
+        "পাইক",
+        "পলাশ",
+        "পার্বতী",
+        "রাম",
+        "রায়",
+        "রানী",
+        "সোনা",
+        "শরণ",
+        "শ্যাম",
+        "সুবর্ণ",
+        "সিরাজ",
+        "সখি",
+        "সদর",
+        "সুন্দর",
+        "সৈয়দ",
+        "শাজাহান",
+        "শান্তি",
+        "শিব",
+        "তের",
+        "তারা",
+        "উজির",
+    )
+
+    building_names = (
+        "বাড়ী নং",
+        "বিল্ডিং নং",
+        "বাসা নং",
+        "হোল্ডিং নং",
+    )
+
+    building_number_formats = ("%", "%#", "%##")
+
+    city_prefixes = ("উত্তর", "পূর্ব", "পশ্চিম", "দক্ষিণ", "মধ্য", "নতুন", "পুরাতন")
+
+    city_suffixes = (
+        "বাজার",
+        "বাড়ি",
+        "চর",
+        "দিয়া",
+        "ডাঙ্গা",
+        "গঞ্জ",
+        "গ্রাম",
+        "গাঁও",
+        "গাঁ",
+        "গড়",
+        "হাট",
+        "হার",
+        "খালি",
+        "মাটি",
+        "নগর",
+        "পুর",
+        "তলা",
+    )
+
+    cities = (
+        "বরগুনা",
+        "বরিশাল",
+        "ভোলা",
+        "বান্দরবান",
+        "ব্রাহ্মণবাড়িয়া",
+        "বাগেরহাট",
+        "বগুড়া",
+        "চাঁদপুর",
+        "চট্টগ্রাম",
+        "কুমিল্লা",
+        "কক্সবাজার",
+        "চুয়াডাঙ্গা",
+        "ঢাকা",
+        "দিনাজপুর",
+        "ফরিদপুর",
+        "ফেনী",
+        "গাজীপুর",
+        "গোপালগঞ্জ",
+        "গাইবান্ধা",
+        "হবিগঞ্জ",
+        "ঝালকাঠি",
+        "যশোর",
+        "ঝিনাইদহ",
+        "জামালপুর",
+        "জয়পুরহাট",
+        "খাগড়াছড়ি",
+        "কিশোরগঞ্জ",
+        "খুলনা",
+        "কুষ্টিয়া",
+        "কুড়িগ্রাম",
+        "লক্ষ্মীপুর",
+        "লালমনিরহাট",
+        "মাদারীপুর",
+        "মানিকগঞ্জ",
+        "মুন্সীগঞ্জ",
+        "মাগুরা",
+        "মেহেরপুর",
+        "ময়মনসিংহ",
+        "মৌলভীবাজার",
+        "নোয়াখালী",
+        "নারায়ণগঞ্জ",
+        "নরসিংদী",
+        "নড়াইল",
+        "নেত্রকোণা",
+        "নওগাঁ",
+        "নাটোর",
+        "চাঁপাইনবাবগঞ্জ",
+        "নীলফামারী",
+        "পটুয়াখালী",
+        "পিরোজপুর",
+        "পাবনা",
+        "পঞ্চগড়",
+        "রাঙ্গামাটি",
+        "রাজবাড়ী",
+        "রাজশাহী",
+        "রংপুর",
+        "শরীয়তপুর",
+        "সাতক্ষীরা",
+        "শেরপুর",
+        "সিরাজগঞ্জ",
+        "সুনামগঞ্জ",
+        "সিলেট",
+        "টাঙ্গাইল",
+        "ঠাকুরগাঁও",
+    )
+
+    countries = (
+        "আফগানিস্তান",
+        "আলবেনিয়া",
+        "আলজেরিয়া",
+        "আমেরিকান সামোয়া",
+        "অ্যান্ডোরা",
+        "অ্যাঙ্গোলা",
+        "অ্যাঙ্গুইলা",
+        "অ্যান্টার্কটিকা",
+        "অ্যান্টিগুয়া ও বার্বুডা",
+        "আর্জেন্টিনা",
+        "আর্মেনিয়া",
+        "আরুবা",
+        "অস্ট্রেলিয়া",
+        "অস্ট্রিয়া",
+        "আজারবাইজান",
+        "বাহামাস",
+        "বাহরাইন",
+        "বাংলাদেশ",
+        "বার্বাডোস",
+        "বেলারুশ",
+        "বেলজিয়াম",
+        "বেলিজ",
+        "বেনিন",
+        "বারমুডা",
+        "ভুটান",
+        "বলিভিয়া",
+        "বসনিয়া-হার্জেগোভিনা",
+        "বতসোয়ানা",
+        "বাউবে দ্বীপ",
+        "ব্রাজিল",
+        "ব্রিটিশ ভারত মহাসাগরীয় অঞ্চল",
+        "ব্রিটিশ ভার্জিন দ্বীপপুঞ্জ",
+        "ব্রুনাই",
+        "বুলগেরিয়া",
+        "বুর্কিনা ফাসো",
+        "বুরুন্ডি",
+        "কম্বোডিয়া",
+        "ক্যামেরুন",
+        "কানাডা",
+        "কেপ ভার্দে",
+        "কেম্যান দ্বীপপুঞ্জ",
+        "মধ্য আফ্রিকান প্রজাতন্ত্র",
+        "চাদ",
+        "চিলি",
+        "চীন",
+        "ক্রিস্টমাস দ্বীপ",
+        "কোকোস দ্বীপপুঞ্জ",
+        "কলাম্বিয়া",
+        "কোমোরোস",
+        "কঙ্গো প্রজাতন্ত্র",
+        "কুক দ্বীপপুঞ্জ",
+        "কোস্টারিকা",
+        "আইভরি কোট",
+        "ক্রোয়েশিয়া",
+        "কিউবা",
+        "সাইপ্রাস প্রজাতন্ত্র",
+        "চেক প্রজাতন্ত্র",
+        "ডেনমার্ক",
+        "জিবুতি প্রজাতন্ত্র",
+        "ডোমিনিকা",
+        "ডোমিনিকান প্রজাতন্ত্র",
+        "ইকুয়েডর",
+        "মিশর",
+        "এল সালভাদর",
+        "নিরক্ষীয় গিনি",
+        "ইরিত্রিয়া",
+        "এস্তোনিয়া",
+        "ইথিওপিয়া",
+        "ফারো দ্বীপপুঞ্জ",
+        "ফকল্যান্ড দ্বীপপুঞ্জ",
+        "ফিজি প্রজাতন্ত্র",
+        "ফিনল্যান্ড",
+        "ফ্রান্স",
+        "একটি দেশের নাম",
+        "ফরাসি পলিনেশিয়া",
+        "ফরাসি সুদূর দক্ষিণ দ্বীপপুঞ্জ",
+        "গ্যাবন",
+        "গাম্বিয়া",
+        "জর্জিয়া",
+        "জার্মানি",
+        "ঘানা",
+        "জিব্রাল্টার",
+        "গ্রীস",
+        "গ্রিনল্যান্ড",
+        "গ্রেনাডা",
+        "গুয়াডেলুপ",
+        "গুয়াম",
+        "গুয়াতেমালা",
+        "গার্নসি",
+        "গিনি",
+        "গিনি-বিসাউ",
+        "গিয়ানা",
+        "হাইতি",
+        "হার্ড আইল্যান্ড এবং ম্যাকডোনাল্ড দ্বীপপুঞ্জ",
+        "ভ্যাটিকান সিটি",
+        "হন্ডুরাস",
+        "হংকং",
+        "হাঙ্গেরি",
+        "আইসল্যান্ড",
+        "ভারত",
+        "ইন্দোনেশিয়া",
+        "ইরান",
+        "ইরাক",
+        "আপনি উত্তর দিবেন না",
+        "আইল অফ ম্যান",
+        "ইসরায়েল",
+        "ইতালি",
+        "জ্যামাইকা",
+        "জাপান",
+        "জার্সি",
+        "জর্ডান",
+        "কাজাখস্তান",
+        "কেনিয়া",
+        "কিরিবাতি",
+        "কোরিয়া",
+        "কোরিয়া",
+        "কুয়েত",
+        "কিরগিজস্তান প্রজাতন্ত্র",
+        "পিপলস ডেমোক্রেটিক রিপাবলিক অফ লাওস",
+        "লাটভিয়া",
+        "লেবানন",
+        "লেসোথো",
+        "লাইবেরিয়া",
+        "লিবিয়া",
+        "লিচেনস্টাইন",
+        "লিথুয়ানিয়া",
+        "লাক্সেমবার্গ",
+        "ম্যাকাও",
+        "উত্তর মেসিডোনিয়া প্রজাতন্ত্র",
+        "মাদাগাস্কার",
+        "মালাউই",
+        "মালয়েশিয়া",
+        "মালদ্বীপ",
+        "মালি",
+        "মাল্টা প্রজাতন্ত্র",
+        "মার্শাল দ্বীপপুঞ্জ",
+        "মার্টিনিক",
+        "ইসলামী প্রজাতন্ত্র মৌরিতানিয়া",
+        "মরিশাস",
+        "মায়োট",
+        "মেক্সিকো",
+        "মাইক্রোনেশিয়ার ফেডারেটেড স্টেটস",
+        "মোল্দোভা প্রজাতন্ত্র",
+        "মোনাকোর রাজত্ব",
+        "মঙ্গোলিয়া",
+        "মন্টিনিগ্রো প্রজাতন্ত্র",
+        "মন্টসেরাট",
+        "মরক্কো",
+        "মোজাম্বিক",
+        "মিয়ানমার",
+        "নামিবিয়া",
+        "নাউরু",
+        "নেপাল",
+        "নেদারল্যান্ডস এন্টিলস",
+        "নেদারল্যান্ডস",
+        "নতুন ক্যালেডোনিয়া",
+        "নিউজিল্যান্ড",
+        "নিকারাগুয়া",
+        "নাইজার",
+        "নাইজেরিয়া",
+        "সুন্দর",
+        "নরফোক দ্বীপ",
+        "উত্তর মারিয়ানা দ্বীপপুঞ্জ",
+        "নরওয়ে",
+        "ওমান",
+        "পাকিস্তান",
+        "পালাউ",
+        "ফিলিস্তিন অঞ্চল",
+        "পানামা",
+        "পাপুয়া নিউ গিনি",
+        "প্যারাগুয়ে",
+        "পেরু",
+        "ফিলিপাইন",
+        "পিটকের্ন দ্বীপপুঞ্জ",
+        "পোল্যান্ড",
+        "পর্তুগাল",
+        "পুয়ের্তো রিকো",
+        "কাতার",
+        "পুনর্মিলন",
+        "রোমানিয়া",
+        "রাশিয়া",
+        "রুয়ান্ডা",
+        "সেন্ট বার্থেলেমি",
+        "সেন্ট হেলেনা",
+        "সেন্ট কিটস ও নেভিস",
+        "সেন্ট লুসিয়া",
+        "সেন্ট মার্টিন",
+        "সেন্ট পিয়ের এবং মিকেলন",
+        "সেন্ট ভিনসেন্ট ও গ্রেনাডাইন দ্বীপপুঞ্জ",
+        "সামোয়া",
+        "সান মারিনো",
+        "স্যান্টোম প্রিন্সিপ",
+        "সৌদি আরব",
+        "সেনেগাল",
+        "সার্বিয়া",
+        "সেশেলস",
+        "সিয়েরা লিওন",
+        "সিঙ্গাপুর",
+        "স্লোভাকিয়া",
+        "স্লোভেনিয়া",
+        "সলোমান দ্বীপপুঞ্জ",
+        "সোমালিয়া",
+        "দক্ষিণ আফ্রিকা প্রজাতন্ত্র",
+        "দক্ষিণ জর্জিয়া এবং দক্ষিণ স্যান্ডউইচ দ্বীপপুঞ্জ",
+        "স্পেন",
+        "শ্রীলংকা",
+        "সুদান",
+        "সুরিনাম",
+        "স্বালবার্ড এবং জানমায়েন দ্বীপপুঞ্জ",
+        "সোয়াজিল্যান্ডের রাজ্য",
+        "সুইডেন",
+        "সুইজারল্যান্ড",
+        "সিরিয়া",
+        "তাইওয়ান",
+        "তাজিকিস্তান প্রজাতন্ত্র",
+        "তানজানিয়া",
+        "থাইল্যান্ড",
+        "পূর্ব তিমুর",
+        "যাও",
+        "টোকেলাউ",
+        "টোঙ্গা",
+        "ত্রিনিদাদ ও টোবাগো প্রজাতন্ত্র",
+        "তিউনিসিয়া",
+        "তুরস্ক",
+        "তুর্কমেনিস্তান",
+        "টার্কস্ ও কেইকোস দ্বীপপুঞ্জ",
+        "টুভালু",
+        "উগান্ডা",
+        "ইউক্রেন",
+        "সংযুক্ত আরব আমিরাত",
+        "ইংল্যান্ড",
+        "মার্কিন যুক্তরাষ্ট্র",
+        "ইউএস মাইনর আউটলি আইল্যান্ড",
+        "আমেরিকান ভার্জিন আইল্যান্ডস",
+        "উরুগুয়ে",
+        "উজবেকিস্তান",
+        "ভানুয়াতু",
+        "ভেনিজুয়েলা",
+        "ভিয়েতনাম",
+        "ওয়ালিস এবং ফুটুনা",
+        "পশ্চিম সাহারা",
+        "ইয়েমেন",
+        "জাম্বিয়া",
+        "জিম্বাবুয়ে",
+    )
+
+    secondary_address_formats = (
+        "ফ্ল্যাট %",
+        "ফ্ল্যাট %#",
+        "ষ্টুডিও %",
+        "ষ্টুডিও %#",
+        "অ্যাপার্টমেন্ট %",
+        "অ্যাপার্টমেন্ট %#",
+    )
+
+    street_suffixes = (
+        "এভিনিউ",
+        "সেন্টার",
+        "চত্বর",
+        "গলি",
+        "ঘাট",
+        "কর্নার",
+        "লেন",
+        "মহাসড়ক",
+        "মহল্লা",
+        "মোড়",
+        "পাড়া",
+        "পার্ক",
+        "প্লাজা",
+        "রাস্তা",
+        "রোড",
+        "সড়ক",
+        "স্টেশন",
+        "স্ট্যান্ড",
+    )
+
+    postcode_formats = ("%###",)
+    street_name_formats = (
+        "{{area_name}}{{street_suffix}}",
+        "{{city_prefix}} {{area_name}}{{street_suffix}}",
+        "{{city_prefix}} {{area_name}}{{city_suffix}}",
+        "{{area_name}}{{city_suffix}}",
+        "{{area_name}}{{city_suffix}} {{street_suffix}}",
+        "{{city_prefix}} {{area_name}}{{city_suffix}} {{street_suffix}}",
+    )
+    street_address_formats = (
+        "{{building_name}} {{building_number}}, {{street_name}}",
+        "{{secondary_address}}, {{building_name}} {{building_number}}, {{street_name}}",
+    )
+    town_formats = ("{{area_name}}{{city_suffix}}",)
+    address_formats = ("{{street_address}}, {{town}}, {{city}}, {{postcode}}",)
+
+    def administrative_unit(self) -> str:
+        """
+        :example: 'ঢাকা'
+        """
+        return self.random_element(self.cities)
+
+    def area_name(self) -> str:
+        """
+        :example: 'উজির'
+        """
+        return self.random_element(self.area_names)
+
+    def building_name(self) -> str:
+        """
+        :example: 'বাড়ী নং'
+        """
+        return self.random_element(self.building_names)
+
+    def building_number(self) -> str:
+        """
+        :example: '791' to '৭৯১'
+        """
+        return translate_to_bengali_digits(self.numerify(self.random_element(self.building_number_formats)))
+
+    def city_prefix(self) -> str:
+        """
+        :example: 'উত্তর'
+        """
+        return self.random_element(self.city_prefixes)
+
+    def city(self) -> str:
+        """
+        :example: 'ঢাকা'
+        """
+        return self.random_element(self.cities)
+
+    def postcode(self) -> str:
+        """
+        See
+        https://bdpost.portal.gov.bd/site/page/6aaeabe4-479b-4e5a-a671-e9e5b994bf9a
+        """
+        return translate_to_bengali_digits(self.numerify(self.random_element(self.postcode_formats)))
+
+    def secondary_address(self) -> str:
+        """
+        As the generated string format is a Bengali word but English number so splitting the value by space
+        and then convert the English number to Bengali number and concat with generated Bengali word
+        and return
+        : example : 'অ্যাপার্টমেন্ট 14' to 'অ্যাপার্টমেন্ট ১৪'
+        """
+        value = self.bothify(self.random_element(self.secondary_address_formats))
+        word_list = value.split(" ")
+        return word_list[0] + " " + translate_to_bengali_digits(word_list[1])
+
+    def town(self) -> str:
+        """
+        :example: 'নবাব'
+        """
+        pattern: str = self.random_element(self.town_formats)
+        return self.generator.parse(pattern)

.venv/lib/python3.12/site-packages/faker/providers/address/de/__init__.py

@@ -0,0 +1,253 @@
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    countries = (
+        "Afghanistan",
+        "Alandinseln",
+        "Albanien",
+        "Algerien",
+        "Amerikanisch-Ozeanien",
+        "Amerikanisch-Samoa",
+        "Amerikanische Jungferninseln",
+        "Andorra",
+        "Angola",
+        "Anguilla",
+        "Antarktis",
+        "Antigua und Barbuda",
+        "Argentinien",
+        "Armenien",
+        "Aruba",
+        "Aserbaidschan",
+        "Australien",
+        "Bahamas",
+        "Bahrain",
+        "Bangladesch",
+        "Barbados",
+        "Belarus",
+        "Belgien",
+        "Belize",
+        "Benin",
+        "Bermuda",
+        "Bhutan",
+        "Bolivien",
+        "Bosnien und Herzegowina",
+        "Botsuana",
+        "Bouvetinsel",
+        "Brasilien",
+        "Britische Jungferninseln",
+        "Britisches Territorium im Indischen Ozean",
+        "Brunei Darussalam",
+        "Bulgarien",
+        "Burkina Faso",
+        "Burundi",
+        "Chile",
+        "China",
+        "Cookinseln",
+        "Costa Rica",
+        "Côte d’Ivoire",
+        "Demokratische Republik Kongo",
+        "Demokratische Volksrepublik Korea",
+        "Deutschland",
+        "Dominica",
+        "Dominikanische Republik",
+        "Dschibuti",
+        "Dänemark",
+        "Ecuador",
+        "El Salvador",
+        "Eritrea",
+        "Estland",
+        "Falklandinseln",
+        "Fidschi",
+        "Finnland",
+        "Frankreich",
+        "Französisch-Guayana",
+        "Französisch-Polynesien",
+        "Färöer",
+        "Gabun",
+        "Gambia",
+        "Georgien",
+        "Ghana",
+        "Gibraltar",
+        "Grenada",
+        "Griechenland",
+        "Grönland",
+        "Guadeloupe",
+        "Guam",
+        "Guatemala",
+        "Guernsey",
+        "Guinea",
+        "Guinea-Bissau",
+        "Guyana",
+        "Haiti",
+        "Heard- und McDonald-Inseln",
+        "Honduras",
+        "Indien",
+        "Indonesien",
+        "Irak",
+        "Iran",
+        "Irland",
+        "Island",
+        "Isle of Man",
+        "Israel",
+        "Italien",
+        "Jamaika",
+        "Japan",
+        "Jemen",
+        "Jersey",
+        "Jordanien",
+        "Kaimaninseln",
+        "Kambodscha",
+        "Kamerun",
+        "Kanada",
+        "Kap Verde",
+        "Kasachstan",
+        "Katar",
+        "Kenia",
+        "Kirgisistan",
+        "Kiribati",
+        "Kokosinseln",
+        "Kolumbien",
+        "Komoren",
+        "Kongo",
+        "Kroatien",
+        "Kuba",
+        "Kuwait",
+        "Laos",
+        "Lesotho",
+        "Lettland",
+        "Libanon",
+        "Liberia",
+        "Libyen",
+        "Liechtenstein",
+        "Litauen",
+        "Luxemburg",
+        "Madagaskar",
+        "Malawi",
+        "Malaysia",
+        "Malediven",
+        "Mali",
+        "Malta",
+        "Marokko",
+        "Marshallinseln",
+        "Martinique",
+        "Mauretanien",
+        "Mauritius",
+        "Mayotte",
+        "Mexiko",
+        "Mikronesien",
+        "Monaco",
+        "Mongolei",
+        "Montenegro",
+        "Montserrat",
+        "Mosambik",
+        "Myanmar",
+        "Namibia",
+        "Nauru",
+        "Nepal",
+        "Neukaledonien",
+        "Neuseeland",
+        "Nicaragua",
+        "Niederlande",
+        "Niederländische Antillen",
+        "Niger",
+        "Nigeria",
+        "Niue",
+        "Nordmazedonien",
+        "Norfolkinsel",
+        "Norwegen",
+        "Nördliche Marianen",
+        "Oman",
+        "Osttimor",
+        "Pakistan",
+        "Palau",
+        "Palästinensische Gebiete",
+        "Panama",
+        "Papua-Neuguinea",
+        "Paraguay",
+        "Peru",
+        "Philippinen",
+        "Pitcairn",
+        "Polen",
+        "Portugal",
+        "Puerto Rico",
+        "Republik Korea",
+        "Republik Moldau",
+        "Ruanda",
+        "Rumänien",
+        "Russische Föderation",
+        "Réunion",
+        "Salomonen",
+        "Sambia",
+        "Samoa",
+        "San Marino",
+        "Saudi-Arabien",
+        "Schweden",
+        "Schweiz",
+        "Senegal",
+        "Serbien",
+        "Serbien und Montenegro",
+        "Seychellen",
+        "Sierra Leone",
+        "Simbabwe",
+        "Singapur",
+        "Slowakei",
+        "Slowenien",
+        "Somalia",
+        "Sonderverwaltungszone Hongkong",
+        "Sonderverwaltungszone Macao",
+        "Spanien",
+        "Sri Lanka",
+        "St. Barthélemy",
+        "St. Helena",
+        "St. Kitts und Nevis",
+        "St. Lucia",
+        "St. Martin",
+        "St. Pierre und Miquelon",
+        "St. Vincent und die Grenadinen",
+        "Sudan",
+        "Suriname",
+        "Svalbard und Jan Mayen",
+        "Swasiland",
+        "Syrien",
+        "São Tomé und Príncipe",
+        "Südafrika",
+        "Südgeorgien und die Südlichen Sandwichinseln",
+        "Tadschikistan",
+        "Taiwan",
+        "Tansania",
+        "Thailand",
+        "Togo",
+        "Tokelau",
+        "Tonga",
+        "Trinidad und Tobago",
+        "Tschad",
+        "Tschechische Republik",
+        "Tunesien",
+        "Turkmenistan",
+        "Turks- und Caicosinseln",
+        "Tuvalu",
+        "Türkei",
+        "Uganda",
+        "Ukraine",
+        "Ungarn",
+        "Uruguay",
+        "Usbekistan",
+        "Vanuatu",
+        "Vatikanstadt",
+        "Venezuela",
+        "Vereinigte Arabische Emirate",
+        "Vereinigte Staaten",
+        "Vereinigtes Königreich",
+        "Vietnam",
+        "Wallis und Futuna",
+        "Weihnachtsinsel",
+        "Westsahara",
+        "Zentralafrikanische Republik",
+        "Zypern",
+        "Ägypten",
+        "Äquatorialguinea",
+        "Äthiopien",
+        "Äußeres Ozeanien",
+        "Österreich",
+    )

.venv/lib/python3.12/site-packages/faker/providers/address/de_AT/__init__.py

@@ -0,0 +1,280 @@
+from ..de import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_formats = ("{{city_name}}",)
+
+    city_with_postcode_formats = ("{{postcode}} {{city}}",)
+
+    street_name_formats = (
+        "{{first_name}}-{{last_name}}-{{street_suffix_long}}",
+        "{{last_name}}{{street_suffix_short}}",
+    )
+    street_address_formats = ("{{street_name}} {{building_number}}",)
+    address_formats = ("{{street_address}}\n{{postcode}} {{city}}",)
+
+    building_number_formats = ("###", "##", "#", "#/#")
+
+    street_suffixes_long = (
+        "Gasse",
+        "Platz",
+        "Ring",
+        "Straße",
+        "Weg",
+    )
+    street_suffixes_short = (
+        "gasse",
+        "platz",
+        "ring",
+        "straße",
+        "str.",
+        "weg",
+    )
+
+    # https://en.wikipedia.org/wiki/List_of_postal_codes_in_Austria
+    postcode_formats = (
+        "1###",
+        "2###",
+        "3###",
+        "4###",
+        "5###",
+        "6###",
+        "7###",
+        "8###",
+        "9###",
+    )
+
+    # https://en.wikipedia.org/wiki/List_of_cities_and_towns_in_Austria
+    cities = (
+        "Allentsteig",
+        "Altheim",
+        "Althofen",
+        "Amstetten",
+        "Ansfelden",
+        "Attnang-Puchheim",
+        "Bad Aussee",
+        "Bad Hall",
+        "Bad Ischl",
+        "Bad Leonfelden",
+        "Bad Radkersburg",
+        "Bad Sankt Leonhard im Lavanttal",
+        "Bad Vöslau",
+        "Baden",
+        "Bärnbach",
+        "Berndorf",
+        "Bischofshofen",
+        "Bleiburg",
+        "Bludenz",
+        "Braunau am Inn",
+        "Bregenz",
+        "Bruck an der Leitha",
+        "Bruck an der Mur",
+        "Deutsch-Wagram",
+        "Deutschlandsberg",
+        "Dornbirn",
+        "Drosendorf-Zissersdorf 1",
+        "Dürnstein",
+        "Ebenfurth",
+        "Ebreichsdorf",
+        "Eferding",
+        "Eggenburg",
+        "Eisenerz",
+        "Eisenstadt",
+        "Enns",
+        "Fehring",
+        "Feldbach",
+        "Feldkirch",
+        "Feldkirchen",
+        "Ferlach",
+        "Fischamend",
+        "Frauenkirchen",
+        "Freistadt",
+        "Friedberg",
+        "Friesach",
+        "Frohnleiten",
+        "Fürstenfeld",
+        "Gallneukirchen",
+        "Gänserndorf",
+        "Geras",
+        "Gerasdorf bei Wien",
+        "Gföhl",
+        "Gleisdorf",
+        "Gloggnitz",
+        "Gmünd",
+        "Gmünd in Kärnten",
+        "Gmunden",
+        "Graz",
+        "Grein",
+        "Grieskirchen",
+        "Groß-Enzersdorf",
+        "Groß-Gerungs",
+        "Groß-Siegharts",
+        "Güssing",
+        "Haag",
+        "Hainburg an der Donau",
+        "Hainfeld",
+        "Hall in Tirol",
+        "Hallein",
+        "Hardegg",
+        "Hartberg",
+        "Heidenreichstein",
+        "Herzogenburg",
+        "Imst",
+        "Innsbruck",
+        "Jennersdorf",
+        "Judenburg",
+        "Kapfenberg",
+        "Kindberg",
+        "Klagenfurt",
+        "Klosterneuburg",
+        "Knittelfeld",
+        "Köflach",
+        "Korneuburg",
+        "Krems an der Donau",
+        "Kufstein",
+        "Laa an der Thaya",
+        "Laakirchen",
+        "Landeck",
+        "Langenlois",
+        "Leibnitz",
+        "Leoben",
+        "Lienz",
+        "Liezen",
+        "Lilienfeld",
+        "Linz",
+        "Litschau",
+        "Maissau",
+        "Mank",
+        "Mannersdorf am Leithagebirge",
+        "Marchegg",
+        "Marchtrenk",
+        "Mariazell",
+        "Mattersburg",
+        "Mattighofen",
+        "Mautern an der Donau",
+        "Melk",
+        "Mistelbach an der Zaya",
+        "Mödling",
+        "Murau",
+        "Mureck",
+        "Mürzzuschlag",
+        "Neulengbach",
+        "Neumarkt am Wallersee",
+        "Neunkirchen",
+        "Neusiedl am See",
+        "Oberndorf bei Salzburg",
+        "Oberpullendorf",
+        "Oberwart",
+        "Oberwälz",
+        "Perg",
+        "Peuerbach",
+        "Pinkafeld",
+        "Pöchlarn",
+        "Poysdorf",
+        "Pregarten",
+        "Pulkau",
+        "Purbach am Neusiedler See",
+        "Purkersdorf",
+        "Raabs an der Thaya",
+        "Radenthein",
+        "Radstadt",
+        "Rattenberg",
+        "Retz",
+        "Ried im Innkreis",
+        "Rohrbach in Oberösterreich",
+        "Rottenmann",
+        "Rust",
+        "Saalfelden am Steinernen Meer",
+        "Salzburg",
+        "Sankt Andrä im Lavanttal",
+        "Sankt Johann im Pongau",
+        "Sankt Pölten",
+        "Sankt Valentin",
+        "Sankt Veit an der Glan",
+        "Schärding",
+        "Scheibbs",
+        "Schladming",
+        "Schrattenthal",
+        "Schrems",
+        "Schwanenstadt",
+        "Schwaz",
+        "Schwechat",
+        "Spittal an der Drau",
+        "Stadtschlaining",
+        "Steyr",
+        "Steyregg",
+        "Stockerau",
+        "Straßburg",
+        "Ternitz",
+        "Traiskirchen",
+        "Traismauer",
+        "Traun",
+        "Trieben",
+        "Trofaiach",
+        "Tulln an der Donau",
+        "Villach",
+        "Vils",
+        "Vöcklabruck",
+        "Voitsberg",
+        "Völkermarkt",
+        "Waidhofen an der Thaya",
+        "Waidhofen an der Ybbs",
+        "Weitra",
+        "Weiz",
+        "Wels",
+        "Wien",
+        "Wiener Neustadt",
+        "Wieselburg",
+        "Wilhelmsburg",
+        "Wolfsberg",
+        "Wolkersdorf",
+        "Wörgl",
+        "Ybbs an der Donau",
+        "Zell am See",
+        "Zeltweg",
+        "Zistersdorf",
+        "Zwettl",
+    )
+
+    # https://en.wikipedia.org/wiki/States_of_Austria
+    states = (
+        "Wien",
+        "Steiermark",
+        "Burgenland",
+        "Tirol",
+        "Niederösterreich",
+        "Oberösterreich",
+        "Salzburg",
+        "Kärnten",
+        "Vorarlberg",
+    )
+
+    municipality_key_formats = (
+        "1####",
+        "2####",
+        "3####",
+        "4####",
+        "5####",
+        "6####",
+        "7####",
+        "8####",
+        "9####",
+    )
+
+    def street_suffix_short(self) -> str:
+        return self.random_element(self.street_suffixes_short)
+
+    def street_suffix_long(self) -> str:
+        return self.random_element(self.street_suffixes_long)
+
+    def city_name(self) -> str:
+        return self.random_element(self.cities)
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.states)
+
+    state = administrative_unit
+
+    def city_with_postcode(self) -> str:
+        pattern: str = self.random_element(self.city_with_postcode_formats)
+        return self.generator.parse(pattern)

.venv/lib/python3.12/site-packages/faker/providers/address/de_CH/__init__.py

@@ -0,0 +1,247 @@
+from typing import Tuple
+
+from ..de import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_formats = ("{{city_name}}",)
+    building_number_formats = ("%", "%#", "%#", "%#", "%##")
+    street_suffixes = ["strasse"]
+    street_name_formats = ("{{last_name}}{{street_suffix}}",)
+    street_address_formats = ("{{street_name}} {{building_number}}",)
+    address_formats = ("{{street_address}}\n{{postcode}} {{city}}",)
+    postcode_formats = (
+        "1###",
+        "2###",
+        "3###",
+        "4###",
+        "5###",
+        "6###",
+        "7###",
+        "8###",
+        "9###",
+    )
+
+    cities = (
+        "Aarau",
+        "Adliswil",
+        "Aesch",
+        "Affoltern",
+        "Aigle",
+        "Allschwil",
+        "Altstätten",
+        "Amriswil",
+        "Arbon",
+        "Arth",
+        "Baar",
+        "Baden",
+        "Basel",
+        "Bassersdorf",
+        "Bellinzona",
+        "Belp",
+        "Bern",
+        "Bernex",
+        "Biel/Bienne",
+        "Binningen",
+        "Birsfelden",
+        "Brig-Glis",
+        "Brugg",
+        "Buchs",
+        "Bülach",
+        "Bulle",
+        "Burgdorf",
+        "Carouge",
+        "Cham",
+        "Chêne-Bougeries",
+        "Chur",
+        "Crans-Montana",
+        "Davos",
+        "Delsberg",
+        "Dietikon",
+        "Dübendorf",
+        "Ebikon",
+        "Ecublens",
+        "Einsiedeln",
+        "Emmen",
+        "Flawil",
+        "Frauenfeld",
+        "Freiburg",
+        "Freienbach",
+        "Genf",
+        "Gland",
+        "Glarus",
+        "Glarus",
+        "Gossau",
+        "Gossau",
+        "Grenchen",
+        "Herisau",
+        "Hinwil",
+        "Horgen",
+        "Horw",
+        "Illnau-Effretikon",
+        "Ittigen",
+        "Kloten",
+        "Köniz",
+        "Kreuzlingen",
+        "Kriens",
+        "Küsnacht",
+        "Küssnacht",
+        "La Chaux-de-Fonds",
+        "La Tour-de-Peilz",
+        "Lancy",
+        "Langenthal",
+        "Lausanne",
+        "Le Grand-Saconnex",
+        "Lenzburg",
+        "Liestal",
+        "Locarno",
+        "Lugano",
+        "Lutry",
+        "Luzern",
+        "Lyss",
+        "Männedorf",
+        "Martigny",
+        "Maur",
+        "Meilen",
+        "Mendrisio",
+        "Meyrin",
+        "Möhlin",
+        "Monthey",
+        "Montreux",
+        "Morges",
+        "Münchenbuchsee",
+        "Münchenstein",
+        "Münsingen",
+        "Muri",
+        "Muttenz",
+        "Naters",
+        "Neuenburg",
+        "Neuhausen",
+        "Nyon",
+        "Oberwil",
+        "Oftringen",
+        "Olten",
+        "Onex",
+        "Opfikon",
+        "Ostermundigen",
+        "Payerne",
+        "Pfäffikon",
+        "Plan-les-Ouates",
+        "Pratteln",
+        "Prilly",
+        "Pully",
+        "Rapperswil-Jona",
+        "Regensdorf",
+        "Reinach",
+        "Renens",
+        "Rheinfelden",
+        "Richterswil",
+        "Riehen",
+        "Risch",
+        "Romanshorn",
+        "Rüti",
+        "Sarnen",
+        "Schaffhausen",
+        "Schlieren",
+        "Schwyz",
+        "Siders",
+        "Sitten",
+        "Solothurn",
+        "Spiez",
+        "Spreitenbach",
+        "St. Gallen",
+        "Stäfa",
+        "Steffisburg",
+        "Steinhausen",
+        "Suhr",
+        "Sursee",
+        "Thalwil",
+        "Thônex",
+        "Thun",
+        "Urdorf",
+        "Uster",
+        "Uzwil",
+        "Val-de-Ruz",
+        "Val-de-Travers",
+        "Vernier",
+        "Versoix",
+        "Vevey",
+        "Veyrier",
+        "Villars-sur-Glâne",
+        "Volketswil",
+        "Wädenswil",
+        "Wald",
+        "Wallisellen",
+        "Weinfelden",
+        "Wettingen",
+        "Wetzikon",
+        "Wil",
+        "Winterthur",
+        "Wohlen",
+        "Worb",
+        "Yverdon-les-Bains",
+        "Zofingen",
+        "Zollikofen",
+        "Zollikon",
+        "Zug",
+        "Zürich",
+    )
+
+    cantons = (
+        ("AG", "Aargau"),
+        ("AI", "Appenzell Innerrhoden"),
+        ("AR", "Appenzell Ausserrhoden"),
+        ("BE", "Bern"),
+        ("BL", "Basel-Landschaft"),
+        ("BS", "Basel-Stadt"),
+        ("FR", "Freiburg"),
+        ("GE", "Genf"),
+        ("GL", "Glarus"),
+        ("GR", "Graubünden"),
+        ("JU", "Jura"),
+        ("LU", "Luzern"),
+        ("NE", "Neuenburg"),
+        ("NW", "Nidwalden"),
+        ("OW", "Obwalden"),
+        ("SG", "St. Gallen"),
+        ("SH", "Schaffhausen"),
+        ("SO", "Solothurn"),
+        ("SZ", "Schwyz"),
+        ("TG", "Thurgau"),
+        ("TI", "Tessin"),
+        ("UR", "Uri"),
+        ("VD", "Waadt"),
+        ("VS", "Wallis"),
+        ("ZG", "Zug"),
+        ("ZH", "Zürich"),
+    )
+
+    def canton(self) -> Tuple[str, str]:
+        """
+        Randomly returns a swiss canton ('Abbreviated', 'Name').
+        :example ('ZH', 'Zürich')
+        """
+        return self.random_element(self.cantons)
+
+    def city_name(self) -> str:
+        """
+        Randomly returns a swiss city.
+        :example 'Zug'
+        """
+        return self.random_element(self.cities)
+
+    def administrative_unit(self) -> str:
+        """
+        Randomly returns a Swiss canton name.
+        :example 'Zürich'
+        """
+        return self.canton()[1]
+
+    canton_name = administrative_unit
+
+    def canton_code(self) -> str:
+        """
+        Randomly returns a Swiss canton code.
+        :example 'ZH'
+        """
+        return self.canton()[0]

.venv/lib/python3.12/site-packages/faker/providers/address/de_DE/__init__.py

@@ -0,0 +1,470 @@
+from ..de import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_formats = ("{{city_name}}",)
+
+    city_with_postcode_formats = ("{{postcode}} {{city}}",)
+
+    street_name_formats = (
+        "{{first_name}}-{{last_name}}-{{street_suffix_long}}",
+        "{{last_name}}{{street_suffix_short}}",
+    )
+    street_address_formats = ("{{street_name}} {{building_number}}",)
+    address_formats = ("{{street_address}}\n{{postcode}} {{city}}",)
+
+    # NOTE: Zero itself can be a valid building number in rare cases e.g., Wilhelm-Wisser-Str. 0, Heidhörn
+    # see: https://www.uniserv.com/wissen/magazin/article/besonderheiten-von-zustelladressen/
+    building_number_formats = ("#", "%#", "%##", "%###", "%/%", "%#/%#", "%-%", "%#-%#")
+
+    street_suffixes_long = (
+        "Gasse",
+        "Platz",
+        "Ring",
+        "Straße",
+        "Weg",
+        "Allee",
+    )
+    street_suffixes_short = (
+        "gasse",
+        "platz",
+        "ring",
+        "straße",
+        "str.",
+        "weg",
+        "allee",
+    )
+
+    postcode_formats = ("#####",)
+
+    cities = (
+        "Aachen",
+        "Ahaus",
+        "Altentreptow",
+        "Altötting",
+        "Amberg",
+        "Angermünde",
+        "Anklam",
+        "Ansbach",
+        "Apolda",
+        "Arnstadt",
+        "Artern",
+        "Aschaffenburg",
+        "Aue",
+        "Auerbach",
+        "Augsburg",
+        "Aurich",
+        "Backnang",
+        "Bad Brückenau",
+        "Bad Freienwalde",
+        "Bad Kissingen",
+        "Bad Kreuznach",
+        "Bad Langensalza",
+        "Bad Liebenwerda",
+        "Bad Mergentheim",
+        "Badalzungen",
+        "Badibling",
+        "Badoberan",
+        "Bamberg",
+        "Bautzen",
+        "Bayreuth",
+        "Beeskow",
+        "Beilngries",
+        "Belzig",
+        "Berchtesgaden",
+        "Bergzabern",
+        "Berlin",
+        "Bernburg",
+        "Bersenbrück",
+        "Biedenkopf",
+        "Bischofswerda",
+        "Bitterfeld",
+        "Bogen",
+        "Borken",
+        "Borna",
+        "Brand",
+        "Brandenburg",
+        "Bremen",
+        "Bremervörde",
+        "Brilon",
+        "Bruchsal",
+        "Burg",
+        "Burgdorf",
+        "Burglengenfeld",
+        "Böblingen",
+        "Büsingen am Hochrhein",
+        "Bützow",
+        "Calau",
+        "Calw",
+        "Celle",
+        "Chemnitz",
+        "Cloppenburg",
+        "Coburg",
+        "Cottbus",
+        "Crailsheim",
+        "Cuxhaven",
+        "Dachau",
+        "Darmstadt",
+        "Deggendorf",
+        "Delitzsch",
+        "Demmin",
+        "Dessau",
+        "Dieburg",
+        "Diepholz",
+        "Dinkelsbühl",
+        "Dinslaken",
+        "Donaueschingen",
+        "Dresden",
+        "Duderstadt",
+        "Döbeln",
+        "Düren",
+        "Ebermannstadt",
+        "Ebern",
+        "Ebersberg",
+        "Eberswalde",
+        "Eckernförde",
+        "Eggenfelden",
+        "Eichstätt",
+        "Eilenburg",
+        "Einbeck",
+        "Eisenach",
+        "Eisenberg",
+        "Eisenhüttenstadt",
+        "Eisleben",
+        "Emmendingen",
+        "Erbisdorf",
+        "Erding",
+        "Erfurt",
+        "Erkelenz",
+        "Euskirchen",
+        "Eutin",
+        "Fallingbostel",
+        "Feuchtwangen",
+        "Finsterwalde",
+        "Flöha",
+        "Forchheim",
+        "Forst",
+        "Freising",
+        "Freital",
+        "Freudenstadt",
+        "Fulda",
+        "Fürstenfeldbruck",
+        "Fürstenwalde",
+        "Füssen",
+        "Gadebusch",
+        "Gardelegen",
+        "Garmisch-Partenkirchen",
+        "Geithain",
+        "Geldern",
+        "Gelnhausen",
+        "Genthin",
+        "Gera",
+        "Germersheim",
+        "Gerolzhofen",
+        "Gießen",
+        "Gifhorn",
+        "Goslar",
+        "Gotha",
+        "Grafenau",
+        "Gransee",
+        "Greifswald",
+        "Greiz",
+        "Grevenbroich",
+        "Grevesmühlen",
+        "Griesbach Rottal",
+        "Grimma",
+        "Grimmen",
+        "Groß-Gerau",
+        "Großenhain",
+        "Gräfenhainichen",
+        "Guben",
+        "Gunzenhausen",
+        "Göppingen",
+        "Görlitz",
+        "Göttingen",
+        "Günzburg",
+        "Güstrow",
+        "Gütersloh",
+        "Hagenow",
+        "Hainichen",
+        "Halberstadt",
+        "Haldensleben",
+        "Hamburg",
+        "Hammelburg",
+        "Hannover",
+        "Hannoversch Münden",
+        "Hansestadttralsund",
+        "Havelberg",
+        "Hechingen",
+        "Heiligenstadt",
+        "Heinsberg",
+        "Helmstedt",
+        "Herford",
+        "Hersbruck",
+        "Herzberg",
+        "Hettstedt",
+        "Hildburghausen",
+        "Hildesheim",
+        "Hofgeismar",
+        "Hohenmölsen",
+        "Hohenstein-Ernstthal",
+        "Holzminden",
+        "Hoyerswerda",
+        "Husum",
+        "Höxter",
+        "Hünfeld",
+        "Illertissen",
+        "Ilmenau",
+        "Ingolstadt",
+        "Iserlohn",
+        "Jena",
+        "Jessen",
+        "Jülich",
+        "Jüterbog",
+        "Kaiserslautern",
+        "Kamenz",
+        "Karlsruhe",
+        "Kassel",
+        "Kehl",
+        "Kelheim",
+        "Kemnath",
+        "Kitzingen",
+        "Kleve",
+        "Klötze",
+        "Koblenz",
+        "Konstanz",
+        "Kronach",
+        "Kulmbach",
+        "Kusel",
+        "Kyritz",
+        "Königs Wusterhausen",
+        "Kötzting",
+        "Leipziger Land",
+        "Lemgo",
+        "Lichtenfels",
+        "Lippstadt",
+        "Lobenstein",
+        "Luckau",
+        "Luckenwalde",
+        "Ludwigsburg",
+        "Ludwigslust",
+        "Lörrach",
+        "Lübben",
+        "Lübeck",
+        "Lübz",
+        "Lüdenscheid",
+        "Lüdinghausen",
+        "Lüneburg",
+        "Magdeburg",
+        "Main-Höchst",
+        "Mainburg",
+        "Malchin",
+        "Mallersdorf",
+        "Marienberg",
+        "Marktheidenfeld",
+        "Mayen",
+        "Meiningen",
+        "Meißen",
+        "Melle",
+        "Mellrichstadt",
+        "Melsungen",
+        "Meppen",
+        "Merseburg",
+        "Mettmann",
+        "Miesbach",
+        "Miltenberg",
+        "Mittweida",
+        "Moers",
+        "Monschau",
+        "Mühldorf am Inn",
+        "Mühlhausen",
+        "München",
+        "Nabburg",
+        "Naila",
+        "Nauen",
+        "Neu-Ulm",
+        "Neubrandenburg",
+        "Neunburg vorm Wald",
+        "Neuruppin",
+        "Neuss",
+        "Neustadt am Rübenberge",
+        "Neustadtner Waldnaab",
+        "Neustrelitz",
+        "Niesky",
+        "Norden",
+        "Nordhausen",
+        "Northeim",
+        "Nördlingen",
+        "Nürtingen",
+        "Oberviechtach",
+        "Ochsenfurt",
+        "Olpe",
+        "Oranienburg",
+        "Oschatz",
+        "Osterburg",
+        "Osterode am Harz",
+        "Paderborn",
+        "Parchim",
+        "Parsberg",
+        "Pasewalk",
+        "Passau",
+        "Pegnitz",
+        "Peine",
+        "Perleberg",
+        "Pfaffenhofen an der Ilm",
+        "Pinneberg",
+        "Pirmasens",
+        "Plauen",
+        "Potsdam",
+        "Prenzlau",
+        "Pritzwalk",
+        "Pößneck",
+        "Quedlinburg",
+        "Querfurt",
+        "Rastatt",
+        "Rathenow",
+        "Ravensburg",
+        "Recklinghausen",
+        "Regen",
+        "Regensburg",
+        "Rehau",
+        "Reutlingen",
+        "Ribnitz-Damgarten",
+        "Riesa",
+        "Rochlitz",
+        "Rockenhausen",
+        "Roding",
+        "Rosenheim",
+        "Rostock",
+        "Roth",
+        "Rothenburg ob der Tauber",
+        "Rottweil",
+        "Rudolstadt",
+        "Saarbrücken",
+        "Saarlouis",
+        "Sangerhausen",
+        "Sankt Goar",
+        "Sankt Goarshausen",
+        "Saulgau",
+        "Scheinfeld",
+        "Schleiz",
+        "Schlüchtern",
+        "Schmölln",
+        "Schongau",
+        "Schrobenhausen",
+        "Schwabmünchen",
+        "Schwandorf",
+        "Schwarzenberg",
+        "Schweinfurt",
+        "Schwerin",
+        "Schwäbisch Gmünd",
+        "Schwäbisch Hall",
+        "Sebnitz",
+        "Seelow",
+        "Senftenberg",
+        "Siegen",
+        "Sigmaringen",
+        "Soest",
+        "Soltau",
+        "Sondershausen",
+        "Sonneberg",
+        "Spremberg",
+        "Stade",
+        "Stadtroda",
+        "Stadtsteinach",
+        "Staffelstein",
+        "Starnberg",
+        "Staßfurt",
+        "Steinfurt",
+        "Stendal",
+        "Sternberg",
+        "Stollberg",
+        "Strasburg",
+        "Strausberg",
+        "Stuttgart",
+        "Suhl",
+        "Sulzbach-Rosenberg",
+        "Säckingen",
+        "Sömmerda",
+        "Tecklenburg",
+        "Teterow",
+        "Tirschenreuth",
+        "Torgau",
+        "Tuttlingen",
+        "Tübingen",
+        "Ueckermünde",
+        "Uelzen",
+        "Uffenheim",
+        "Vechta",
+        "Viechtach",
+        "Viersen",
+        "Vilsbiburg",
+        "Vohenstrauß",
+        "Waldmünchen",
+        "Wanzleben",
+        "Waren",
+        "Warendorf",
+        "Weimar",
+        "Weißenfels",
+        "Weißwasser",
+        "Werdau",
+        "Wernigerode",
+        "Wertingen",
+        "Wesel",
+        "Wetzlar",
+        "Wiedenbrück",
+        "Wismar",
+        "Wittenberg",
+        "Wittmund",
+        "Wittstock",
+        "Witzenhausen",
+        "Wolfach",
+        "Wolfenbüttel",
+        "Wolfratshausen",
+        "Wolgast",
+        "Wolmirstedt",
+        "Worbis",
+        "Wunsiedel",
+        "Wurzen",
+        "Zerbst",
+        "Zeulenroda",
+        "Zossen",
+        "Zschopau",
+    )
+
+    states = (
+        "Baden-Württemberg",
+        "Bayern",
+        "Berlin",
+        "Brandenburg",
+        "Bremen",
+        "Hamburg",
+        "Hessen",
+        "Mecklenburg-Vorpommern",
+        "Niedersachsen",
+        "Nordrhein-Westfalen",
+        "Rheinland-Pfalz",
+        "Saarland",
+        "Sachsen",
+        "Sachsen-Anhalt",
+        "Schleswig-Holstein",
+        "Thüringen",
+    )
+
+    def street_suffix_short(self) -> str:
+        return self.random_element(self.street_suffixes_short)
+
+    def street_suffix_long(self) -> str:
+        return self.random_element(self.street_suffixes_long)
+
+    def city_name(self) -> str:
+        return self.random_element(self.cities)
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.states)
+
+    state = administrative_unit
+
+    def city_with_postcode(self) -> str:
+        pattern: str = self.random_element(self.city_with_postcode_formats)
+        return self.generator.parse(pattern)

.venv/lib/python3.12/site-packages/faker/providers/address/en/__init__.py

@@ -0,0 +1,251 @@
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    countries = (
+        "Afghanistan",
+        "Albania",
+        "Algeria",
+        "American Samoa",
+        "Andorra",
+        "Angola",
+        "Anguilla",
+        "Antarctica (the territory South of 60 deg S)",
+        "Antigua and Barbuda",
+        "Argentina",
+        "Armenia",
+        "Aruba",
+        "Australia",
+        "Austria",
+        "Azerbaijan",
+        "Bahamas",
+        "Bahrain",
+        "Bangladesh",
+        "Barbados",
+        "Belarus",
+        "Belgium",
+        "Belize",
+        "Benin",
+        "Bermuda",
+        "Bhutan",
+        "Bolivia",
+        "Bosnia and Herzegovina",
+        "Botswana",
+        "Bouvet Island (Bouvetoya)",
+        "Brazil",
+        "British Indian Ocean Territory (Chagos Archipelago)",
+        "British Virgin Islands",
+        "Brunei Darussalam",
+        "Bulgaria",
+        "Burkina Faso",
+        "Burundi",
+        "Cambodia",
+        "Cameroon",
+        "Canada",
+        "Cape Verde",
+        "Cayman Islands",
+        "Central African Republic",
+        "Chad",
+        "Chile",
+        "China",
+        "Christmas Island",
+        "Cocos (Keeling) Islands",
+        "Colombia",
+        "Comoros",
+        "Congo",
+        "Congo",
+        "Cook Islands",
+        "Costa Rica",
+        "Cote d'Ivoire",
+        "Croatia",
+        "Cuba",
+        "Cyprus",
+        "Czech Republic",
+        "Denmark",
+        "Djibouti",
+        "Dominica",
+        "Dominican Republic",
+        "Ecuador",
+        "Egypt",
+        "El Salvador",
+        "Equatorial Guinea",
+        "Eritrea",
+        "Estonia",
+        "Ethiopia",
+        "Faroe Islands",
+        "Falkland Islands (Malvinas)",
+        "Fiji",
+        "Finland",
+        "France",
+        "French Guiana",
+        "French Polynesia",
+        "French Southern Territories",
+        "Gabon",
+        "Gambia",
+        "Georgia",
+        "Germany",
+        "Ghana",
+        "Gibraltar",
+        "Greece",
+        "Greenland",
+        "Grenada",
+        "Guadeloupe",
+        "Guam",
+        "Guatemala",
+        "Guernsey",
+        "Guinea",
+        "Guinea-Bissau",
+        "Guyana",
+        "Haiti",
+        "Heard Island and McDonald Islands",
+        "Holy See (Vatican City State)",
+        "Honduras",
+        "Hong Kong",
+        "Hungary",
+        "Iceland",
+        "India",
+        "Indonesia",
+        "Iran",
+        "Iraq",
+        "Ireland",
+        "Isle of Man",
+        "Israel",
+        "Italy",
+        "Jamaica",
+        "Japan",
+        "Jersey",
+        "Jordan",
+        "Kazakhstan",
+        "Kenya",
+        "Kiribati",
+        "Korea",
+        "Korea",
+        "Kuwait",
+        "Kyrgyz Republic",
+        "Lao People's Democratic Republic",
+        "Latvia",
+        "Lebanon",
+        "Lesotho",
+        "Liberia",
+        "Libyan Arab Jamahiriya",
+        "Liechtenstein",
+        "Lithuania",
+        "Luxembourg",
+        "Macao",
+        "Madagascar",
+        "Malawi",
+        "Malaysia",
+        "Maldives",
+        "Mali",
+        "Malta",
+        "Marshall Islands",
+        "Martinique",
+        "Mauritania",
+        "Mauritius",
+        "Mayotte",
+        "Mexico",
+        "Micronesia",
+        "Moldova",
+        "Monaco",
+        "Mongolia",
+        "Montenegro",
+        "Montserrat",
+        "Morocco",
+        "Mozambique",
+        "Myanmar",
+        "Namibia",
+        "Nauru",
+        "Nepal",
+        "Netherlands Antilles",
+        "Netherlands",
+        "New Caledonia",
+        "New Zealand",
+        "Nicaragua",
+        "Niger",
+        "Nigeria",
+        "Niue",
+        "Norfolk Island",
+        "North Macedonia",
+        "Northern Mariana Islands",
+        "Norway",
+        "Oman",
+        "Pakistan",
+        "Palau",
+        "Palestinian Territory",
+        "Panama",
+        "Papua New Guinea",
+        "Paraguay",
+        "Peru",
+        "Philippines",
+        "Pitcairn Islands",
+        "Poland",
+        "Portugal",
+        "Puerto Rico",
+        "Qatar",
+        "Reunion",
+        "Romania",
+        "Russian Federation",
+        "Rwanda",
+        "Saint Barthelemy",
+        "Saint Helena",
+        "Saint Kitts and Nevis",
+        "Saint Lucia",
+        "Saint Martin",
+        "Saint Pierre and Miquelon",
+        "Saint Vincent and the Grenadines",
+        "Samoa",
+        "San Marino",
+        "Sao Tome and Principe",
+        "Saudi Arabia",
+        "Senegal",
+        "Serbia",
+        "Seychelles",
+        "Sierra Leone",
+        "Singapore",
+        "Slovakia (Slovak Republic)",
+        "Slovenia",
+        "Solomon Islands",
+        "Somalia",
+        "South Africa",
+        "South Georgia and the South Sandwich Islands",
+        "Spain",
+        "Sri Lanka",
+        "Sudan",
+        "Suriname",
+        "Svalbard & Jan Mayen Islands",
+        "Swaziland",
+        "Sweden",
+        "Switzerland",
+        "Syrian Arab Republic",
+        "Taiwan",
+        "Tajikistan",
+        "Tanzania",
+        "Thailand",
+        "Timor-Leste",
+        "Togo",
+        "Tokelau",
+        "Tonga",
+        "Trinidad and Tobago",
+        "Tunisia",
+        "Turkey",
+        "Turkmenistan",
+        "Turks and Caicos Islands",
+        "Tuvalu",
+        "Uganda",
+        "Ukraine",
+        "United Arab Emirates",
+        "United Kingdom",
+        "United States of America",
+        "United States Minor Outlying Islands",
+        "United States Virgin Islands",
+        "Uruguay",
+        "Uzbekistan",
+        "Vanuatu",
+        "Venezuela",
+        "Vietnam",
+        "Wallis and Futuna",
+        "Western Sahara",
+        "Yemen",
+        "Zambia",
+        "Zimbabwe",
+    )

.venv/lib/python3.12/site-packages/faker/providers/address/en_AU/__init__.py

@@ -0,0 +1,342 @@
+from ..en import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_prefixes = ("North", "East", "West", "South", "New", "Lake", "Port", "St.")
+
+    city_suffixes = (
+        "town",
+        "ton",
+        "land",
+        "ville",
+        "berg",
+        "burgh",
+        "borough",
+        "bury",
+        "view",
+        "port",
+        "mouth",
+        "stad",
+        "furt",
+        "chester",
+        "mouth",
+        "fort",
+        "haven",
+        "side",
+        "shire",
+    )
+
+    building_number_formats = ("###", "##", "#")
+
+    street_suffixes = (
+        "Access",
+        "Alley",
+        "Alleyway",
+        "Amble",
+        "Anchorage",
+        "Approach",
+        "Arcade",
+        "Artery",
+        "Avenue",
+        "Basin",
+        "Beach",
+        "Bend",
+        "Block",
+        "Boulevard",
+        "Brace",
+        "Brae",
+        "Break",
+        "Bridge",
+        "Broadway",
+        "Brow",
+        "Bypass",
+        "Byway",
+        "Causeway",
+        "Centre",
+        "Centreway",
+        "Chase",
+        "Circle",
+        "Circlet",
+        "Circuit",
+        "Circus",
+        "Close",
+        "Colonnade",
+        "Common",
+        "Concourse",
+        "Copse",
+        "Corner",
+        "Corso",
+        "Court",
+        "Courtyard",
+        "Cove",
+        "Crescent",
+        "Crest",
+        "Cross",
+        "Crossing",
+        "Crossroad",
+        "Crossway",
+        "Cruiseway",
+        "Cul-de-sac",
+        "Cutting",
+        "Dale",
+        "Dell",
+        "Deviation",
+        "Dip",
+        "Distributor",
+        "Drive",
+        "Driveway",
+        "Edge",
+        "Elbow",
+        "End",
+        "Entrance",
+        "Esplanade",
+        "Estate",
+        "Expressway",
+        "Extension",
+        "Fairway",
+        "Fire Track",
+        "Firetrail",
+        "Flat",
+        "Follow",
+        "Footway",
+        "Foreshore",
+        "Formation",
+        "Freeway",
+        "Front",
+        "Frontage",
+        "Gap",
+        "Garden",
+        "Gardens",
+        "Gate",
+        "Gates",
+        "Glade",
+        "Glen",
+        "Grange",
+        "Green",
+        "Ground",
+        "Grove",
+        "Gully",
+        "Heights",
+        "Highroad",
+        "Highway",
+        "Hill",
+        "Interchange",
+        "Intersection",
+        "Junction",
+        "Key",
+        "Landing",
+        "Lane",
+        "Laneway",
+        "Lees",
+        "Line",
+        "Link",
+        "Little",
+        "Lookout",
+        "Loop",
+        "Lower",
+        "Mall",
+        "Meander",
+        "Mew",
+        "Mews",
+        "Motorway",
+        "Mount",
+        "Nook",
+        "Outlook",
+        "Parade",
+        "Park",
+        "Parklands",
+        "Parkway",
+        "Part",
+        "Pass",
+        "Path",
+        "Pathway",
+        "Piazza",
+        "Place",
+        "Plateau",
+        "Plaza",
+        "Pocket",
+        "Point",
+        "Port",
+        "Promenade",
+        "Quad",
+        "Quadrangle",
+        "Quadrant",
+        "Quay",
+        "Quays",
+        "Ramble",
+        "Ramp",
+        "Range",
+        "Reach",
+        "Reserve",
+        "Rest",
+        "Retreat",
+        "Ride",
+        "Ridge",
+        "Ridgeway",
+        "Right Of Way",
+        "Ring",
+        "Rise",
+        "River",
+        "Riverway",
+        "Riviera",
+        "Road",
+        "Roads",
+        "Roadside",
+        "Roadway",
+        "Ronde",
+        "Rosebowl",
+        "Rotary",
+        "Round",
+        "Route",
+        "Row",
+        "Rue",
+        "Run",
+        "Service Way",
+        "Siding",
+        "Slope",
+        "Sound",
+        "Spur",
+        "Square",
+        "Stairs",
+        "State Highway",
+        "Steps",
+        "Strand",
+        "Street",
+        "Strip",
+        "Subway",
+        "Tarn",
+        "Terrace",
+        "Thoroughfare",
+        "Tollway",
+        "Top",
+        "Tor",
+        "Towers",
+        "Track",
+        "Trail",
+        "Trailer",
+        "Triangle",
+        "Trunkway",
+        "Turn",
+        "Underpass",
+        "Upper",
+        "Vale",
+        "Viaduct",
+        "View",
+        "Villas",
+        "Vista",
+        "Wade",
+        "Walk",
+        "Walkway",
+        "Way",
+        "Wynd",
+    )
+
+    postcode_formats = (
+        # as per https://en.wikipedia.org/wiki/Postcodes_in_Australia
+        # NSW
+        "1###",
+        "20##",
+        "21##",
+        "22##",
+        "23##",
+        "24##",
+        "25##",
+        "2619",
+        "262#",
+        "263#",
+        "264#",
+        "265#",
+        "266#",
+        "267#",
+        "268#",
+        "269#",
+        "27##",
+        "28##",
+        "292#",
+        "293#",
+        "294#",
+        "295#",
+        "296#",
+        "297#",
+        "298#",
+        "299#",
+        # ACT
+        "02##",
+        "260#",
+        "261#",
+        "290#",
+        "291#",
+        "2920",
+        # VIC
+        "3###",
+        "8###",
+        # QLD
+        "4###",
+        "9###",
+        # SA
+        "5###",
+        # WA
+        "6###",
+        # TAS
+        "7###",
+        # NT
+        "08##",
+        "09##",
+    )
+
+    states = (
+        "Australian Capital Territory",
+        "New South Wales",
+        "Northern Territory",
+        "Queensland",
+        "South Australia",
+        "Tasmania",
+        "Victoria",
+        "Western Australia",
+    )
+
+    states_abbr = ("ACT", "NSW", "NT", "QLD", "SA", "TAS", "VIC", "WA")
+
+    city_formats = (
+        "{{city_prefix}} {{first_name}}{{city_suffix}}",
+        "{{city_prefix}} {{first_name}}",
+        "{{first_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+    )
+
+    street_name_formats = (
+        "{{first_name}} {{street_suffix}}",
+        "{{last_name}} {{street_suffix}}",
+    )
+
+    street_address_formats = (
+        "{{building_number}} {{street_name}}",
+        "{{secondary_address}}{{building_number}} {{street_name}}",
+    )
+
+    address_formats = ("{{street_address}}\n{{city}}, {{state_abbr}}, {{postcode}}",)
+
+    secondary_address_formats = (
+        "Apt. ### ",
+        "Flat ## ",
+        "Suite ### ",
+        "Unit ## ",
+        "Level # ",
+        "###/",
+        "##/",
+        "#/",
+    )
+
+    def city_prefix(self) -> str:
+        return self.random_element(self.city_prefixes)
+
+    def secondary_address(self) -> str:
+        return self.numerify(self.random_element(self.secondary_address_formats))
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.states)
+
+    state = administrative_unit
+
+    def state_abbr(self) -> str:
+        return self.random_element(self.states_abbr)

.venv/lib/python3.12/site-packages/faker/providers/address/en_BD/__init__.py

@@ -0,0 +1,547 @@
+"""
+Contributed by: @aamibhoot 🇧🇩
+"""
+
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    area_names = (
+        "Ali",
+        "Alam",
+        "Abhay",
+        "Anwar",
+        "Brahmin",
+        "Botia",
+        "Baghar",
+        "Begum",
+        "Bijoy",
+        "Bandar",
+        "Balia",
+        "Bajit",
+        "Baker",
+        "Borhan",
+        "Bakhsh",
+        "Badr",
+        "Biram",
+        "Biswnath",
+        "Chouddah",
+        "Chital",
+        "Daud",
+        "Daulat",
+        "Dev",
+        "Devi",
+        "Islam",
+        "Ful",
+        "Fakir",
+        "Fatik",
+        "Gopal",
+        "Gour",
+        "Haji",
+        "Hariram",
+        "Hossain",
+        "Hakim",
+        "Jibon",
+        "Jagannath",
+        "Kumar",
+        "Kali",
+        "Keshav",
+        "Qutub",
+        "Kabi",
+        "Kalia",
+        "Karim",
+        "Kazi",
+        "Kamal",
+        "Lal",
+        "Murad",
+        "Manohar",
+        "Mir",
+        "Mahes",
+        "Moral",
+        "Molla",
+        "Mohammad",
+        "Maniram",
+        "Manik",
+        "Mirza",
+        "Mud",
+        "Mohan",
+        "Mahadev",
+        "Madhab",
+        "Nasir",
+        "Naria",
+        "Nazir",
+        "Nalitha",
+        "Nandi",
+        "Osmani",
+        "Pai",
+        "Palash",
+        "Parvati",
+        "Ram",
+        "Ray",
+        "Rani",
+        "Sona",
+        "Sharan",
+        "Shyam",
+        "Subarna",
+        "Siraj",
+        "Sakhi",
+        "Sadar",
+        "Sundar",
+        "Syed",
+        "Shahjahan",
+        "Shanti",
+        "Shib",
+        "Ter",
+        "Tara",
+        "Uzir",
+    )
+
+    building_names = (
+        "House No.",
+        "Building No.",
+        "House No.",
+        "Holding No.",
+    )
+
+    building_number_formats = ("%", "%#", "%##")
+
+    city_prefixes = ("North", "East", "West", "South", "Middle", "New", "Old")
+
+    city_suffixes = (
+        "Bazar",
+        "Bari",
+        "Char",
+        "Diya",
+        "Danga",
+        "Ganz",
+        "Gram",
+        "Gan",
+        "Gan",
+        "Garh",
+        "Hat",
+        "Har",
+        "Khali",
+        "Mati",
+        "Nagar",
+        "Pur",
+        "Tala",
+    )
+
+    cities = (
+        "Barguna",
+        "Barisal",
+        "Bhola",
+        "Bandarban",
+        "Brahmanbaria",
+        "Bagherhat",
+        "Bogura",
+        "Chandpur",
+        "Chittagong",
+        "Cumilla",
+        "Cox's Bazar",
+        "Chuadanga",
+        "Dhaka",
+        "Dinajpur",
+        "Faripur",
+        "Feni",
+        "Gazipur",
+        "Gopalganj",
+        "Gaibandha",
+        "Habiganj",
+        "Jhalokati",
+        "Jessore",
+        "Jhenaidah",
+        "Jamalpur",
+        "Joypurhat",
+        "Khagrachhari",
+        "Kishoreganj",
+        "Khulna",
+        "Kushtia",
+        "Kurigram",
+        "Lakshmipur",
+        "Lalmonirhat",
+        "Madaripur",
+        "Manikganj",
+        "Munshiganj",
+        "Magura",
+        "Meherpur",
+        "Mymensingh",
+        "Maulvibazar",
+        "Noakhali",
+        "Narayanganj",
+        "Narsingdi",
+        "Narail",
+        "Netrokona",
+        "Naogaon",
+        "Naogaon",
+        "Chapainawabganj",
+        "Nilphamari",
+        "Patuakhali",
+        "Pirojpur",
+        "Pabna",
+        "Panchagarh",
+        "Rangpur",
+        "Shariatpur",
+        "Satkhira",
+        "Sherpur",
+        "Sirajganj",
+        "Sunamganj",
+        "Sylhet",
+        "Tangail",
+        "Thakurgaon",
+    )
+
+    countries = (
+        "Afghanistan",
+        "Albania",
+        "Algeria",
+        "American Samoa",
+        "Andorra",
+        "Angola",
+        "Anguilla",
+        "Antarctica (the territory South of 60 deg S)",
+        "Antigua and Barbuda",
+        "Argentina",
+        "Armenia",
+        "Aruba",
+        "Australia",
+        "Austria",
+        "Azerbaijan",
+        "Bahamas",
+        "Bahrain",
+        "Bangladesh",
+        "Barbados",
+        "Belarus",
+        "Belgium",
+        "Belize",
+        "Benin",
+        "Bermuda",
+        "Bhutan",
+        "Bolivia",
+        "Bosnia and Herzegovina",
+        "Botswana",
+        "Bouvet Island (Bouvetoya)",
+        "Brazil",
+        "British Indian Ocean Territory (Chagos Archipelago)",
+        "British Virgin Islands",
+        "Brunei Darussalam",
+        "Bulgaria",
+        "Burkina Faso",
+        "Burundi",
+        "Cambodia",
+        "Cameroon",
+        "Canada",
+        "Cape Verde",
+        "Cayman Islands",
+        "Central African Republic",
+        "Chad",
+        "Chile",
+        "China",
+        "Christmas Island",
+        "Cocos (Keeling) Islands",
+        "Colombia",
+        "Comoros",
+        "Congo",
+        "Congo",
+        "Cook Islands",
+        "Costa Rica",
+        "Cote d'Ivoire",
+        "Croatia",
+        "Cuba",
+        "Cyprus",
+        "Czech Republic",
+        "Denmark",
+        "Djibouti",
+        "Dominica",
+        "Dominican Republic",
+        "Ecuador",
+        "Egypt",
+        "El Salvador",
+        "Equatorial Guinea",
+        "Eritrea",
+        "Estonia",
+        "Ethiopia",
+        "Faroe Islands",
+        "Falkland Islands (Malvinas)",
+        "Fiji",
+        "Finland",
+        "France",
+        "French Guiana",
+        "French Polynesia",
+        "French Southern Territories",
+        "Gabon",
+        "Gambia",
+        "Georgia",
+        "Germany",
+        "Ghana",
+        "Gibraltar",
+        "Greece",
+        "Greenland",
+        "Grenada",
+        "Guadeloupe",
+        "Guam",
+        "Guatemala",
+        "Guernsey",
+        "Guinea",
+        "Guinea-Bissau",
+        "Guyana",
+        "Haiti",
+        "Heard Island and McDonald Islands",
+        "Holy See (Vatican City State)",
+        "Honduras",
+        "Hong Kong",
+        "Hungary",
+        "Iceland",
+        "India",
+        "Indonesia",
+        "Iran",
+        "Iraq",
+        "Ireland",
+        "Isle of Man",
+        "Israel",
+        "Italy",
+        "Jamaica",
+        "Japan",
+        "Jersey",
+        "Jordan",
+        "Kazakhstan",
+        "Kenya",
+        "Kiribati",
+        "Korea",
+        "Korea",
+        "Kuwait",
+        "Kyrgyz Republic",
+        "Lao People's Democratic Republic",
+        "Latvia",
+        "Lebanon",
+        "Lesotho",
+        "Liberia",
+        "Libyan Arab Jamahiriya",
+        "Liechtenstein",
+        "Lithuania",
+        "Luxembourg",
+        "Macao",
+        "Madagascar",
+        "Malawi",
+        "Malaysia",
+        "Maldives",
+        "Mali",
+        "Malta",
+        "Marshall Islands",
+        "Martinique",
+        "Mauritania",
+        "Mauritius",
+        "Mayotte",
+        "Mexico",
+        "Micronesia",
+        "Moldova",
+        "Monaco",
+        "Mongolia",
+        "Montenegro",
+        "Montserrat",
+        "Morocco",
+        "Mozambique",
+        "Myanmar",
+        "Namibia",
+        "Nauru",
+        "Nepal",
+        "Netherlands Antilles",
+        "Netherlands",
+        "New Caledonia",
+        "New Zealand",
+        "Nicaragua",
+        "Niger",
+        "Nigeria",
+        "Niue",
+        "Norfolk Island",
+        "North Macedonia",
+        "Northern Mariana Islands",
+        "Norway",
+        "Oman",
+        "Pakistan",
+        "Palau",
+        "Palestinian Territory",
+        "Panama",
+        "Papua New Guinea",
+        "Paraguay",
+        "Peru",
+        "Philippines",
+        "Pitcairn Islands",
+        "Poland",
+        "Portugal",
+        "Puerto Rico",
+        "Qatar",
+        "Reunion",
+        "Romania",
+        "Russian Federation",
+        "Rwanda",
+        "Saint Barthelemy",
+        "Saint Helena",
+        "Saint Kitts and Nevis",
+        "Saint Lucia",
+        "Saint Martin",
+        "Saint Pierre and Miquelon",
+        "Saint Vincent and the Grenadines",
+        "Samoa",
+        "San Marino",
+        "Sao Tome and Principe",
+        "Saudi Arabia",
+        "Senegal",
+        "Serbia",
+        "Seychelles",
+        "Sierra Leone",
+        "Singapore",
+        "Slovakia (Slovak Republic)",
+        "Slovenia",
+        "Solomon Islands",
+        "Somalia",
+        "South Africa",
+        "South Georgia and the South Sandwich Islands",
+        "Spain",
+        "Sri Lanka",
+        "Sudan",
+        "Suriname",
+        "Svalbard & Jan Mayen Islands",
+        "Swaziland",
+        "Sweden",
+        "Switzerland",
+        "Syrian Arab Republic",
+        "Taiwan",
+        "Tajikistan",
+        "Tanzania",
+        "Thailand",
+        "Timor-Leste",
+        "Togo",
+        "Tokelau",
+        "Tonga",
+        "Trinidad and Tobago",
+        "Tunisia",
+        "Turkey",
+        "Turkmenistan",
+        "Turks and Caicos Islands",
+        "Tuvalu",
+        "Uganda",
+        "Ukraine",
+        "United Arab Emirates",
+        "United Kingdom",
+        "United States of America",
+        "United States Minor Outlying Islands",
+        "United States Virgin Islands",
+        "Uruguay",
+        "Uzbekistan",
+        "Vanuatu",
+        "Venezuela",
+        "Vietnam",
+        "Wallis and Futuna",
+        "Western Sahara",
+        "Yemen",
+        "Zambia",
+        "Zimbabwe",
+    )
+
+    secondary_address_formats = (
+        "Flat %",
+        "Flat %#",
+        "Studio %",
+        "Studio %#",
+        "Apartment %",
+        "Apartment %#",
+    )
+
+    street_suffixes = (
+        "Avenue",
+        "Center",
+        "Square",
+        "Lane",
+        "Ghat",
+        "Corner",
+        "Lane",
+        "Highway",
+        "Mohalla",
+        "Moor",
+        "Para",
+        "Park",
+        "Plaza",
+        "Road",
+        "Road",
+        "Sorok",
+        "Station",
+        "Stand",
+    )
+
+    postcode_formats = ("%###",)
+    street_name_formats = (
+        "{{area_name}}{{street_suffix}}",
+        "{{city_prefix}} {{area_name}}{{street_suffix}}",
+        "{{city_prefix}} {{area_name}}{{city_suffix}}",
+        "{{area_name}}{{city_suffix}}",
+        "{{area_name}}{{city_suffix}} {{street_suffix}}",
+        "{{city_prefix}} {{area_name}}{{city_suffix}} {{street_suffix}}",
+    )
+    street_address_formats = (
+        "{{building_name}} {{building_number}}, {{street_name}}",
+        "{{secondary_address}}, {{building_name}} {{building_number}}, {{street_name}}",
+    )
+    town_formats = ("{{area_name}}{{city_suffix}}",)
+    address_formats = ("{{street_address}}, {{town}}, {{city}}, {{postcode}}",)
+
+    def administrative_unit(self) -> str:
+        """
+        :example: 'Dhaka'
+        """
+        return self.random_element(self.cities)
+
+    def area_name(self) -> str:
+        """
+        :example: 'Dhanmondi'
+        """
+        return self.random_element(self.area_names)
+
+    def building_name(self) -> str:
+        """
+        :example: 'House No.'
+        """
+        return self.random_element(self.building_names)
+
+    def building_number(self) -> str:
+        """
+        :example: '791'
+        """
+        return self.numerify(self.random_element(self.building_number_formats))
+
+    def city_prefix(self) -> str:
+        """
+        :example: 'North'
+        """
+        return self.random_element(self.city_prefixes)
+
+    def city(self) -> str:
+        """
+        :example: 'Dhaka'
+        """
+        return self.random_element(self.cities)
+
+    def postcode(self) -> str:
+        """
+        See
+        https://bdpost.portal.gov.bd/site/page/6aaeabe4-479b-4e5a-a671-e9e5b994bf9a
+        """
+        return self.numerify(self.random_element(self.postcode_formats))
+
+    def secondary_address(self) -> str:
+        """
+        As the generated string format is a Bengali word but English number so splitting the value by space
+        and then convert the English number to Bengali number and concat with generated Bengali word
+        and return
+        : example : 'Apartment 123'
+        """
+        value = self.bothify(self.random_element(self.secondary_address_formats))
+        word_list = value.split(" ")
+        return word_list[0] + " " + word_list[1]
+
+    def town(self) -> str:
+        """
+        :example: 'Dhanmondi'
+        """
+        pattern: str = self.random_element(self.town_formats)
+        return self.generator.parse(pattern)

.venv/lib/python3.12/site-packages/faker/providers/address/en_CA/__init__.py

@@ -0,0 +1,417 @@
+import re
+
+from typing import Optional
+
+from faker.providers import ElementsType
+
+from ..en import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    #  Source: https://www.canadapost.ca/tools/pg/manual/PGaddress-e.asp#1449294
+    #
+    #  'W' and 'Z' are valid in non-initial position (easily verified in the
+    #  wild), but online official documentation is hard to find, so just ignore
+    #  them for now.
+    postal_code_letters = (
+        "A",
+        "B",
+        "C",
+        "E",
+        "G",
+        "H",
+        "J",
+        "K",
+        "L",
+        "M",
+        "N",
+        "P",
+        "R",
+        "S",
+        "T",
+        "V",
+        "X",
+        "Y",
+    )
+
+    city_prefixes: ElementsType[str] = ("North", "East", "West", "South", "New", "Lake", "Port")
+
+    city_suffixes: ElementsType[str] = (
+        "town",
+        "ton",
+        "land",
+        "ville",
+        "berg",
+        "burgh",
+        "borough",
+        "bury",
+        "view",
+        "port",
+        "mouth",
+        "stad",
+        "furt",
+        "chester",
+        "mouth",
+        "fort",
+        "haven",
+        "side",
+        "shire",
+    )
+
+    building_number_formats = ("#####", "####", "###")
+
+    street_suffixes = (
+        "Alley",
+        "Avenue",
+        "Branch",
+        "Bridge",
+        "Brook",
+        "Brooks",
+        "Burg",
+        "Burgs",
+        "Bypass",
+        "Camp",
+        "Canyon",
+        "Cape",
+        "Causeway",
+        "Center",
+        "Centers",
+        "Circle",
+        "Circles",
+        "Cliff",
+        "Cliffs",
+        "Club",
+        "Common",
+        "Corner",
+        "Corners",
+        "Course",
+        "Court",
+        "Courts",
+        "Cove",
+        "Coves",
+        "Creek",
+        "Crescent",
+        "Crest",
+        "Crossing",
+        "Crossroad",
+        "Curve",
+        "Dale",
+        "Dam",
+        "Divide",
+        "Drive",
+        "Drive",
+        "Drives",
+        "Estate",
+        "Estates",
+        "Expressway",
+        "Extension",
+        "Extensions",
+        "Fall",
+        "Falls",
+        "Ferry",
+        "Field",
+        "Fields",
+        "Flat",
+        "Flats",
+        "Ford",
+        "Fords",
+        "Forest",
+        "Forge",
+        "Forges",
+        "Fork",
+        "Forks",
+        "Fort",
+        "Freeway",
+        "Garden",
+        "Gardens",
+        "Gateway",
+        "Glen",
+        "Glens",
+        "Green",
+        "Greens",
+        "Grove",
+        "Groves",
+        "Harbor",
+        "Harbors",
+        "Haven",
+        "Heights",
+        "Highway",
+        "Hill",
+        "Hills",
+        "Hollow",
+        "Inlet",
+        "Inlet",
+        "Island",
+        "Island",
+        "Islands",
+        "Islands",
+        "Isle",
+        "Isle",
+        "Junction",
+        "Junctions",
+        "Key",
+        "Keys",
+        "Knoll",
+        "Knolls",
+        "Lake",
+        "Lakes",
+        "Land",
+        "Landing",
+        "Lane",
+        "Light",
+        "Lights",
+        "Loaf",
+        "Lock",
+        "Locks",
+        "Locks",
+        "Lodge",
+        "Lodge",
+        "Loop",
+        "Mall",
+        "Manor",
+        "Manors",
+        "Meadow",
+        "Meadows",
+        "Mews",
+        "Mill",
+        "Mills",
+        "Mission",
+        "Mission",
+        "Motorway",
+        "Mount",
+        "Mountain",
+        "Mountain",
+        "Mountains",
+        "Mountains",
+        "Neck",
+        "Orchard",
+        "Oval",
+        "Overpass",
+        "Park",
+        "Parks",
+        "Parkway",
+        "Parkways",
+        "Pass",
+        "Passage",
+        "Path",
+        "Pike",
+        "Pine",
+        "Pines",
+        "Place",
+        "Plain",
+        "Plains",
+        "Plains",
+        "Plaza",
+        "Plaza",
+        "Point",
+        "Points",
+        "Port",
+        "Port",
+        "Ports",
+        "Ports",
+        "Prairie",
+        "Prairie",
+        "Radial",
+        "Ramp",
+        "Ranch",
+        "Rapid",
+        "Rapids",
+        "Rest",
+        "Ridge",
+        "Ridges",
+        "River",
+        "Road",
+        "Road",
+        "Roads",
+        "Roads",
+        "Route",
+        "Row",
+        "Rue",
+        "Run",
+        "Shoal",
+        "Shoals",
+        "Shore",
+        "Shores",
+        "Skyway",
+        "Spring",
+        "Springs",
+        "Springs",
+        "Spur",
+        "Spurs",
+        "Square",
+        "Square",
+        "Squares",
+        "Squares",
+        "Station",
+        "Station",
+        "Stravenue",
+        "Stravenue",
+        "Stream",
+        "Stream",
+        "Street",
+        "Street",
+        "Streets",
+        "Summit",
+        "Summit",
+        "Terrace",
+        "Throughway",
+        "Trace",
+        "Track",
+        "Trafficway",
+        "Trail",
+        "Trail",
+        "Tunnel",
+        "Tunnel",
+        "Turnpike",
+        "Turnpike",
+        "Underpass",
+        "Union",
+        "Unions",
+        "Valley",
+        "Valleys",
+        "Via",
+        "Viaduct",
+        "View",
+        "Views",
+        "Village",
+        "Village",
+        "Villages",
+        "Ville",
+        "Vista",
+        "Vista",
+        "Walk",
+        "Walks",
+        "Wall",
+        "Way",
+        "Ways",
+        "Well",
+        "Wells",
+    )
+
+    postal_code_formats = ("?%? %?%", "?%?%?%")
+
+    provinces = (
+        "Alberta",
+        "British Columbia",
+        "Manitoba",
+        "New Brunswick",
+        "Newfoundland and Labrador",
+        "Northwest Territories",
+        "Nova Scotia",
+        "Nunavut",
+        "Ontario",
+        "Prince Edward Island",
+        "Quebec",
+        "Saskatchewan",
+        "Yukon Territory",
+    )
+
+    provinces_abbr = (
+        "AB",
+        "BC",
+        "MB",
+        "NB",
+        "NL",
+        "NT",
+        "NS",
+        "NU",
+        "ON",
+        "PE",
+        "QC",
+        "SK",
+        "YT",
+    )
+
+    provinces_postcode_prefixes = {
+        "NL": ["A"],
+        "NS": ["B"],
+        "PE": ["C"],
+        "NB": ["E"],
+        "QC": ["G", "H", "J"],
+        "ON": ["K", "L", "M", "N", "P"],
+        "MB": ["R"],
+        "SK": ["S"],
+        "AB": ["T"],
+        "BC": ["V"],
+        "NU": ["X"],
+        "NT": ["X"],
+        "YT": ["Y"],
+    }
+
+    city_formats: ElementsType[str] = (
+        "{{city_prefix}} {{first_name}}{{city_suffix}}",
+        "{{city_prefix}} {{first_name}}",
+        "{{first_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+    )
+    street_name_formats = (
+        "{{first_name}} {{street_suffix}}",
+        "{{last_name}} {{street_suffix}}",
+    )
+    street_address_formats = (
+        "{{building_number}} {{street_name}}",
+        "{{building_number}} {{street_name}} {{secondary_address}}",
+    )
+    address_formats = ("{{street_address}}\n{{city}}, {{province_abbr}} {{postalcode}}",)
+    secondary_address_formats = ("Apt. ###", "Suite ###")
+
+    def administrative_unit(self) -> str:
+        """ """
+        return self.random_element(self.provinces)
+
+    province = administrative_unit
+
+    def province_abbr(self) -> str:
+        return self.random_element(self.provinces_abbr)
+
+    def city_prefix(self) -> str:
+        return self.random_element(self.city_prefixes)
+
+    def secondary_address(self) -> str:
+        return self.numerify(self.random_element(self.secondary_address_formats))
+
+    def postal_code_letter(self) -> str:
+        """
+        Returns a random letter from the list of allowable
+        letters in a canadian postal code
+        """
+        return self.random_element(self.postal_code_letters)
+
+    def _postcode_replace(self, postal_code_format: str) -> str:
+        """
+        Replaces all question mark ('?') occurrences with a random letter
+        from given postal_code_format, then passes result to numerify to insert
+        numbers
+        """
+        temp = re.sub(r"\?", lambda x: self.postal_code_letter(), postal_code_format)
+        return self.numerify(temp)
+
+    def postcode(self) -> str:
+        """
+        Returns a random postcode
+        """
+        return self._postcode_replace(self.random_element(self.postal_code_formats))
+
+    def postcode_in_province(self, province_abbr: Optional[str] = None) -> str:
+        """
+        Returns a random postcode within the provided province abbreviation
+        """
+        if province_abbr is None:
+            province_abbr = self.random_element(self.provinces_abbr)
+
+        if province_abbr in self.provinces_abbr:
+            postal_code_format: str = self.random_element(self.postal_code_formats)
+            postal_code_format = postal_code_format.replace(
+                "?",
+                self.generator.random_element(self.provinces_postcode_prefixes[province_abbr]),
+                1,
+            )
+            return self._postcode_replace(postal_code_format)
+        else:
+            raise Exception("Province Abbreviation not found in list")
+
+    def postalcode_in_province(self, province_abbr: Optional[str] = None) -> str:
+        return self.postcode_in_province(province_abbr)
+
+    def postalcode(self) -> str:
+        return self.postcode()

.venv/lib/python3.12/site-packages/faker/providers/address/en_GB/__init__.py

@@ -0,0 +1,550 @@
+from collections import OrderedDict
+
+from ..en import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_prefixes = ("North", "East", "West", "South", "New", "Lake", "Port")
+    city_suffixes = (
+        "town",
+        "ton",
+        "land",
+        "ville",
+        "berg",
+        "burgh",
+        "borough",
+        "bury",
+        "view",
+        "port",
+        "mouth",
+        "stad",
+        "furt",
+        "chester",
+        "mouth",
+        "fort",
+        "haven",
+        "side",
+        "shire",
+    )
+    counties = (
+        "Bedfordshire",
+        "Buckinghamshire",
+        "Cambridgeshire",
+        "Cheshire",
+        "Cleveland",
+        "Cornwall",
+        "Cumbria",
+        "Derbyshire",
+        "Devon",
+        "Dorset",
+        "Durham",
+        "East Sussex",
+        "Essex",
+        "Gloucestershire",
+        "Greater London",
+        "Greater Manchester",
+        "Hampshire",
+        "Hertfordshire",
+        "Kent",
+        "Lancashire",
+        "Leicestershire",
+        "Lincolnshire",
+        "Merseyside",
+        "Norfolk",
+        "North Yorkshire",
+        "Northamptonshire",
+        "Northumberland",
+        "Nottinghamshire",
+        "Oxfordshire",
+        "Shropshire",
+        "Somerset",
+        "South Yorkshire",
+        "Staffordshire",
+        "Suffolk",
+        "Surrey",
+        "Tyne and Wear",
+        "Warwickshire",
+        "West Berkshire",
+        "West Midlands",
+        "West Sussex",
+        "West Yorkshire",
+        "Wiltshire",
+        "Worcestershire",
+        "Flintshire",
+        "Glamorgan",
+        "Merionethshire",
+        "Monmouthshire",
+        "Montgomeryshire",
+        "Pembrokeshire",
+        "Radnorshire",
+        "Anglesey",
+        "Breconshire",
+        "Caernarvonshire",
+        "Cardiganshire",
+        "Carmarthenshire",
+        "Denbighshire",
+        "Aberdeen City",
+        "Aberdeenshire",
+        "Angus",
+        "Argyll and Bute",
+        "City of Edinburgh",
+        "Clackmannanshire",
+        "Dumfries and Galloway",
+        "Dundee City",
+        "East Ayrshire",
+        "East Dunbartonshire",
+        "East Lothian",
+        "East Renfrewshire",
+        "Eilean Siar",
+        "Falkirk",
+        "Fife",
+        "Glasgow City",
+        "Highland",
+        "Inverclyde",
+        "Midlothian",
+        "Moray",
+        "North Ayrshire",
+        "North Lanarkshire",
+        "Orkney Islands",
+        "Perth and Kinross",
+        "Renfrewshire",
+        "Scottish Borders",
+        "Shetland Islands",
+        "South Ayrshire",
+        "South Lanarkshire",
+        "Stirling",
+        "West Dunbartonshire",
+        "West Lothian",
+        "Antrim",
+        "Armagh",
+        "Down",
+        "Fermanagh",
+        "Derry and Londonderry",
+        "Tyrone",
+    )
+    building_number_formats = ("#", "##", "###")
+    street_suffixes = (
+        "Alley",
+        "Avenue",
+        "Branch",
+        "Bridge",
+        "Brook",
+        "Brooks",
+        "Burg",
+        "Burgs",
+        "Bypass",
+        "Camp",
+        "Canyon",
+        "Cape",
+        "Causeway",
+        "Center",
+        "Centers",
+        "Circle",
+        "Circles",
+        "Cliff",
+        "Cliffs",
+        "Club",
+        "Common",
+        "Corner",
+        "Corners",
+        "Course",
+        "Court",
+        "Courts",
+        "Cove",
+        "Coves",
+        "Creek",
+        "Crescent",
+        "Crest",
+        "Crossing",
+        "Crossroad",
+        "Curve",
+        "Dale",
+        "Dam",
+        "Divide",
+        "Drive",
+        "Drive",
+        "Drives",
+        "Estate",
+        "Estates",
+        "Expressway",
+        "Extension",
+        "Extensions",
+        "Fall",
+        "Falls",
+        "Ferry",
+        "Field",
+        "Fields",
+        "Flat",
+        "Flats",
+        "Ford",
+        "Fords",
+        "Forest",
+        "Forge",
+        "Forges",
+        "Fork",
+        "Forks",
+        "Fort",
+        "Freeway",
+        "Garden",
+        "Gardens",
+        "Gateway",
+        "Glen",
+        "Glens",
+        "Green",
+        "Greens",
+        "Grove",
+        "Groves",
+        "Harbor",
+        "Harbors",
+        "Haven",
+        "Heights",
+        "Highway",
+        "Hill",
+        "Hills",
+        "Hollow",
+        "Inlet",
+        "Inlet",
+        "Island",
+        "Island",
+        "Islands",
+        "Islands",
+        "Isle",
+        "Isle",
+        "Junction",
+        "Junctions",
+        "Key",
+        "Keys",
+        "Knoll",
+        "Knolls",
+        "Lake",
+        "Lakes",
+        "Land",
+        "Landing",
+        "Lane",
+        "Light",
+        "Lights",
+        "Loaf",
+        "Lock",
+        "Locks",
+        "Locks",
+        "Lodge",
+        "Lodge",
+        "Loop",
+        "Mall",
+        "Manor",
+        "Manors",
+        "Meadow",
+        "Meadows",
+        "Mews",
+        "Mill",
+        "Mills",
+        "Mission",
+        "Mission",
+        "Motorway",
+        "Mount",
+        "Mountain",
+        "Mountain",
+        "Mountains",
+        "Mountains",
+        "Neck",
+        "Orchard",
+        "Oval",
+        "Overpass",
+        "Park",
+        "Parks",
+        "Parkway",
+        "Parkways",
+        "Pass",
+        "Passage",
+        "Path",
+        "Pike",
+        "Pine",
+        "Pines",
+        "Place",
+        "Plain",
+        "Plains",
+        "Plains",
+        "Plaza",
+        "Plaza",
+        "Point",
+        "Points",
+        "Port",
+        "Port",
+        "Ports",
+        "Ports",
+        "Prairie",
+        "Prairie",
+        "Radial",
+        "Ramp",
+        "Ranch",
+        "Rapid",
+        "Rapids",
+        "Rest",
+        "Ridge",
+        "Ridges",
+        "River",
+        "Road",
+        "Road",
+        "Roads",
+        "Roads",
+        "Route",
+        "Row",
+        "Rue",
+        "Run",
+        "Shoal",
+        "Shoals",
+        "Shore",
+        "Shores",
+        "Skyway",
+        "Spring",
+        "Springs",
+        "Springs",
+        "Spur",
+        "Spurs",
+        "Square",
+        "Square",
+        "Squares",
+        "Squares",
+        "Station",
+        "Station",
+        "Stravenue",
+        "Stravenue",
+        "Stream",
+        "Stream",
+        "Street",
+        "Street",
+        "Streets",
+        "Summit",
+        "Summit",
+        "Terrace",
+        "Throughway",
+        "Trace",
+        "Track",
+        "Trafficway",
+        "Trail",
+        "Trail",
+        "Tunnel",
+        "Tunnel",
+        "Turnpike",
+        "Turnpike",
+        "Underpass",
+        "Union",
+        "Unions",
+        "Valley",
+        "Valleys",
+        "Via",
+        "Viaduct",
+        "View",
+        "Views",
+        "Village",
+        "Village",
+        "Villages",
+        "Ville",
+        "Vista",
+        "Vista",
+        "Walk",
+        "Walks",
+        "Wall",
+        "Way",
+        "Ways",
+        "Well",
+        "Wells",
+    )
+
+    POSTAL_ZONES = (
+        "AB",
+        "AL",
+        "B",
+        "BA",
+        "BB",
+        "BD",
+        "BH",
+        "BL",
+        "BN",
+        "BR",
+        "BS",
+        "BT",
+        "CA",
+        "CB",
+        "CF",
+        "CH",
+        "CM",
+        "CO",
+        "CR",
+        "CT",
+        "CV",
+        "CW",
+        "DA",
+        "DD",
+        "DE",
+        "DG",
+        "DH",
+        "DL",
+        "DN",
+        "DT",
+        "DY",
+        "E",
+        "EC",
+        "EH",
+        "EN",
+        "EX",
+        "FK",
+        "FY",
+        "G",
+        "GL",
+        "GY",
+        "GU",
+        "HA",
+        "HD",
+        "HG",
+        "HP",
+        "HR",
+        "HS",
+        "HU",
+        "HX",
+        "IG",
+        "IM",
+        "IP",
+        "IV",
+        "JE",
+        "KA",
+        "KT",
+        "KW",
+        "KY",
+        "L",
+        "LA",
+        "LD",
+        "LE",
+        "LL",
+        "LN",
+        "LS",
+        "LU",
+        "M",
+        "ME",
+        "MK",
+        "ML",
+        "N",
+        "NE",
+        "NG",
+        "NN",
+        "NP",
+        "NR",
+        "NW",
+        "OL",
+        "OX",
+        "PA",
+        "PE",
+        "PH",
+        "PL",
+        "PO",
+        "PR",
+        "RG",
+        "RH",
+        "RM",
+        "S",
+        "SA",
+        "SE",
+        "SG",
+        "SK",
+        "SL",
+        "SM",
+        "SN",
+        "SO",
+        "SP",
+        "SR",
+        "SS",
+        "ST",
+        "SW",
+        "SY",
+        "TA",
+        "TD",
+        "TF",
+        "TN",
+        "TQ",
+        "TR",
+        "TS",
+        "TW",
+        "UB",
+        "W",
+        "WA",
+        "WC",
+        "WD",
+        "WF",
+        "WN",
+        "WR",
+        "WS",
+        "WV",
+        "YO",
+        "ZE",
+    )
+
+    POSTAL_ZONES_ONE_CHAR = [zone for zone in POSTAL_ZONES if len(zone) == 1]
+    POSTAL_ZONES_TWO_CHARS = [zone for zone in POSTAL_ZONES if len(zone) == 2]
+
+    postcode_formats = (
+        "AN NEE",
+        "ANN NEE",
+        "PN NEE",
+        "PNN NEE",
+        "ANC NEE",
+        "PND NEE",
+    )
+
+    _postcode_sets = OrderedDict(
+        (
+            (" ", " "),
+            ("N", [str(i) for i in range(0, 10)]),
+            ("A", POSTAL_ZONES_ONE_CHAR),
+            ("B", "ABCDEFGHKLMNOPQRSTUVWXY"),
+            ("C", "ABCDEFGHJKSTUW"),
+            ("D", "ABEHMNPRVWXY"),
+            ("E", "ABDEFGHJLNPQRSTUWXYZ"),
+            ("P", POSTAL_ZONES_TWO_CHARS),
+        )
+    )
+
+    city_formats = (
+        "{{city_prefix}} {{first_name}}{{city_suffix}}",
+        "{{city_prefix}} {{first_name}}",
+        "{{first_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+    )
+    street_name_formats = (
+        "{{first_name}} {{street_suffix}}",
+        "{{last_name}} {{street_suffix}}",
+    )
+    street_address_formats = (
+        "{{building_number}} {{street_name}}",
+        "{{secondary_address}}\n{{street_name}}",
+    )
+    address_formats = ("{{street_address}}\n{{city}}\n{{postcode}}",)
+    secondary_address_formats = (
+        "Flat #",
+        "Flat ##",
+        "Flat ##?",
+        "Studio #",
+        "Studio ##",
+        "Studio ##?",
+    )
+
+    def postcode(self) -> str:
+        """
+        See
+        http://web.archive.org/web/20090930140939/http://www.govtalk.gov.uk/gdsc/html/noframes/PostCode-2-1-Release.htm
+        """
+        postcode = ""
+        pattern: str = self.random_element(self.postcode_formats)
+        for placeholder in pattern:
+            postcode += self.random_element(self._postcode_sets[placeholder])
+        return postcode
+
+    def city_prefix(self) -> str:
+        return self.random_element(self.city_prefixes)
+
+    def secondary_address(self) -> str:
+        return self.bothify(self.random_element(self.secondary_address_formats))
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.counties)
+
+    county = administrative_unit

.venv/lib/python3.12/site-packages/faker/providers/address/en_IE/__init__.py

@@ -0,0 +1,61 @@
+from collections import OrderedDict
+
+from ..en import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    counties = (
+        "Cork",
+        "Galway",
+        "Mayo",
+        "Donegal",
+        "Kerry",
+        "Tipperary",
+        "Clare",
+        "Tyrone",
+        "Antrim",
+        "Limerick",
+        "Roscommon",
+        "Down",
+        "Meath",
+        "Londonderry",
+        "Wexford",
+        "Kilkenny",
+        "Offaly",
+        "Cavan",
+        "Wicklow",
+        "Waterford",
+        "Sligo",
+        "Laois",
+        "Westmeath",
+        "Kildare",
+        "Leitrim",
+        "Armagh",
+        "Fermanagh",
+        "Monaghan",
+        "Dublin",
+        "Louth",
+        "Longford",
+        "Carlow",
+    )
+
+    _postcode_sets = OrderedDict(
+        (
+            (" ", [" ", ""]),
+            ("N", [str(i) for i in range(0, 10)]),
+            ("L", "ACDEFHKNPRTVWXY"),
+            ("A", "ACDEFHKNPRTVWXY0123456789"),
+        )
+    )
+    postcode_pattern: str = "LNN AAAA"
+
+    def postcode(self) -> str:
+        postcode = ""
+        for placeholder in self.postcode_pattern:
+            postcode += self.random_element(self._postcode_sets[placeholder])
+        return postcode
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.counties)
+
+    county = administrative_unit

.venv/lib/python3.12/site-packages/faker/providers/address/en_IN/__init__.py

@@ -0,0 +1,572 @@
+from typing import Dict, List, Optional, Tuple
+
+from faker.providers.address import Provider as AddressProvider
+
+Range = Tuple[int, int]
+
+
+class Provider(AddressProvider):
+    # City and States names taken from wikipedia
+    # Street format taken from some common famous places in India
+    # Link for cities: https://en.wikipedia.org/wiki/List_of_cities_in_India_by_population
+    # Link for States: https://en.wikipedia.org/wiki/States_and_union_territories_of_India
+    # Links for street name formats: https://www.mumbai77.com/city/3313/travel/old-new-street-names/
+
+    city_formats = ("{{city_name}}",)
+
+    street_name_formats = (
+        "{{last_name}} Nagar",
+        "{{last_name}} Zila",
+        "{{last_name}} Street",
+        "{{last_name}} Ganj",
+        "{{last_name}} Road",
+        "{{last_name}} Path",
+        "{{last_name}} Marg",
+        "{{last_name}} Chowk",
+        "{{last_name}} Circle",
+        "{{last_name}}",
+    )
+
+    street_address_formats = (
+        "{{building_number}}, {{street_name}}",
+        "{{building_number}}\n{{street_name}}",
+    )
+
+    address_formats = (
+        "{{street_address}}\n{{city}} {{postcode}}",
+        "{{street_address}}\n{{city}}-{{postcode}}",
+        "{{street_address}}, {{city}} {{postcode}}",
+        "{{street_address}}, {{city}}-{{postcode}}",
+    )
+
+    building_number_formats = ("H.No. ###", "###", "H.No. ##", "##", "##/##", "##/###")
+
+    postcode_formats = ("######",)
+
+    cities = (
+        "Mumbai",
+        "Delhi",
+        "Kolkata",
+        "Chennai",
+        "Bangalore",
+        "Hyderabad",
+        "Ahmedabad",
+        "Kanpur",
+        "Pune",
+        "Surat",
+        "Jaipur",
+        "Lucknow",
+        "Nagpur",
+        "Indore",
+        "Bhopal",
+        "Ludhiana",
+        "Patna",
+        "Visakhapatnam",
+        "Vadodara",
+        "Agra",
+        "Thane",
+        "Kalyan-Dombivli",
+        "Varanasi",
+        "Ranchi",
+        "Nashik",
+        "Dhanbad",
+        "Faridabad",
+        "Meerut",
+        "Pimpri-Chinchwad",
+        "Howrah",
+        "Allahabad",
+        "Ghaziabad",
+        "Rajkot",
+        "Amritsar",
+        "Jabalpur",
+        "Coimbatore",
+        "Madurai",
+        "Srinagar",
+        "Aurangabad",
+        "Solapur",
+        "Vijayawada",
+        "Jodhpur",
+        "Gwalior",
+        "Guwahati",
+        "Chandigarh",
+        "Hubli–Dharwad",
+        "Mysore",
+        "Tiruchirappalli",
+        "Bareilly",
+        "Jalandhar",
+        "Navi Mumbai",
+        "Salem",
+        "Kota",
+        "Vasai-Virar",
+        "Aligarh",
+        "Moradabad",
+        "Bhubaneswar",
+        "Gorakhpur",
+        "Raipur",
+        "Bhiwandi",
+        "Kochi",
+        "Jamshedpur",
+        "Bhilai",
+        "Amravati",
+        "Cuttack",
+        "Warangal",
+        "Bikaner",
+        "Mira-Bhayandar",
+        "Guntur",
+        "Bhavnagar",
+        "Durgapur",
+        "Kolhapur",
+        "Ajmer",
+        "Asansol",
+        "Ulhasnagar",
+        "Siliguri",
+        "Jalgaon",
+        "Saharanpur",
+        "Jamnagar",
+        "Bhatpara",
+        "Sangli-Miraj & Kupwad",
+        "Kozhikode",
+        "Nanded",
+        "Ujjain",
+        "Dehradun",
+        "Rourkela",
+        "Gulbarga",
+        "Tirunelveli",
+        "Malegaon",
+        "Akola",
+        "Belgaum",
+        "Mangalore",
+        "Bokaro",
+        "South Dumdum",
+        "Udaipur",
+        "Gaya",
+        "Maheshtala",
+        "Jhansi",
+        "Nellore",
+        "Jammu",
+        "Thiruvananthapuram",
+        "Davanagere",
+        "Kollam",
+        "Panihati",
+        "Kurnool",
+        "Tiruppur",
+        "Dhule",
+        "Bhagalpur",
+        "Rajpur Sonarpur",
+        "Kakinada",
+        "Thrissur",
+        "Bellary",
+        "Muzaffarnagar",
+        "Korba",
+        "Rajahmundry",
+        "Kamarhati",
+        "Ambattur",
+        "Berhampur",
+        "Ahmednagar",
+        "Muzaffarpur",
+        "Noida",
+        "Patiala",
+        "Mathura",
+        "New Delhi",
+        "Latur",
+        "Sambalpur",
+        "Shahjahanpur",
+        "Kulti",
+        "Chandrapur",
+        "Nizamabad",
+        "Rohtak",
+        "Bardhaman",
+        "Rampur",
+        "Bhilwara",
+        "Firozabad",
+        "Bilaspur",
+        "Shimoga",
+        "Agartala",
+        "Gopalpur",
+        "Darbhanga",
+        "Panipat",
+        "Bally",
+        "Alwar",
+        "Parbhani",
+        "Ichalkaranji",
+        "Anantapuram",
+        "Baranagar",
+        "Tumkur",
+        "Ramagundam",
+        "Jalna",
+        "Durg",
+        "Sagar",
+        "Bihar Sharif",
+        "Dewas",
+        "Barasat",
+        "Avadi",
+        "Farrukhabad",
+        "Aizawl",
+        "Tirupati",
+        "Bijapur",
+        "Satara",
+        "Satna",
+        "Ratlam",
+        "Imphal",
+        "Pondicherry",
+        "North Dumdum",
+        "Anantapur",
+        "Khammam",
+        "Ozhukarai",
+        "Bathinda",
+        "Thoothukudi",
+        "Thanjavur",
+        "Naihati",
+        "Sonipat",
+        "Mau",
+        "Tiruvottiyur",
+        "Hapur",
+        "Sri Ganganagar",
+        "Karnal",
+        "Etawah",
+        "Nagercoil",
+        "Raichur",
+        "Raurkela Industrial Township",
+        "Secunderabad",
+        "Karimnagar",
+        "Mirzapur",
+        "Bharatpur",
+        "Ambarnath",
+        "Arrah",
+        "Uluberia",
+        "Serampore",
+        "Dindigul",
+        "Gandhinagar",
+        "Burhanpur",
+        "Nadiad",
+        "Eluru",
+        "Yamunanagar",
+        "Kharagpur",
+        "Munger",
+        "Pali",
+        "Katni",
+        "Singrauli",
+        "Tenali",
+        "Sikar",
+        "Silchar",
+        "Rewa",
+        "Sambhal",
+        "Machilipatnam",
+        "Vellore",
+        "Alappuzha",
+        "Bulandshahr",
+        "Haridwar",
+        "Vijayanagaram",
+        "Erode",
+        "Gurgaon",
+        "Bidar",
+        "Bhusawal",
+        "Khandwa",
+        "Purnia",
+        "Haldia",
+        "Chinsurah",
+        "Bhiwani",
+        "Raebareli",
+        "Junagadh",
+        "Bahraich",
+        "Gandhidham",
+        "Mango",
+        "Raiganj",
+        "Amroha",
+        "Sultan Pur Majra",
+        "Hospet",
+        "Bidhannagar",
+        "Malda",
+        "Sirsa",
+        "Berhampore",
+        "Jaunpur",
+        "Surendranagar Dudhrej",
+        "Madhyamgram",
+        "Kirari Suleman Nagar",
+        "Bhind",
+        "Nandyal",
+        "Chittoor",
+        "Bhalswa Jahangir Pur",
+        "Fatehpur",
+        "Morena",
+        "Nangloi Jat",
+        "Ongole",
+        "Karawal Nagar",
+        "Shivpuri",
+        "Morbi",
+        "Unnao",
+        "Pallavaram",
+        "Kumbakonam",
+        "Shimla",
+        "Mehsana",
+        "Panchkula",
+        "Orai",
+        "Ambala",
+        "Dibrugarh",
+        "Guna",
+        "Danapur",
+        "Sasaram",
+        "Anand",
+        "Kottayam",
+        "Hazaribagh",
+        "Kadapa",
+        "Saharsa",
+        "Nagaon",
+        "Loni",
+        "Hajipur",
+        "Dehri",
+        "Bettiah",
+        "Katihar",
+        "Deoghar",
+        "Jorhat",
+        "Siwan",
+        "Panvel",
+        "Hosur",
+        "Tinsukia",
+        "Bongaigaon",
+        "Motihari",
+        "Jamalpur",
+        "Suryapet",
+        "Begusarai",
+        "Miryalaguda",
+        "Proddatur",
+        "Karaikudi",
+        "Kishanganj",
+        "Phusro",
+        "Buxar",
+        "Tezpur",
+        "Jehanabad",
+        "Aurangabad",
+        "Chapra",
+        "Ramgarh",
+        "Gangtok",
+        "Adoni",
+        "Amaravati",
+        "Ballia",
+        "Bhimavaram",
+        "Dharmavaram",
+        "Giridih",
+        "Gudivada",
+        "Guntakal",
+        "Hindupur",
+        "Kavali",
+        "Khora ",
+        "Ghaziabad",
+        "Madanapalle",
+        "Mahbubnagar",
+        "Medininagar",
+        "Narasaraopet",
+        "Phagwara",
+        "Pudukkottai",
+        "Srikakulam",
+        "Tadepalligudem",
+        "Tadipatri",
+        "Udupi",
+    )
+
+    states = (
+        "Andhra Pradesh",
+        "Arunachal Pradesh",
+        "Assam",
+        "Bihar",
+        "Chhattisgarh",
+        "Goa",
+        "Gujarat",
+        "Haryana",
+        "Himachal Pradesh",
+        "Jharkhand",
+        "Karnataka",
+        "Kerala",
+        "Madhya Pradesh",
+        "Maharashtra",
+        "Manipur",
+        "Meghalaya",
+        "Mizoram",
+        "Nagaland",
+        "Odisha",
+        "Punjab",
+        "Rajasthan",
+        "Sikkim",
+        "Tamil Nadu",
+        "Telangana",
+        "Tripura",
+        "Uttar Pradesh",
+        "Uttarakhand",
+        "West Bengal",
+    )
+
+    states_abbr: Tuple[str, ...] = (
+        "AP",
+        "AR",
+        "AS",
+        "BR",
+        "CG",
+        "GA",
+        "GJ",
+        "HR",
+        "HP",
+        "JH",
+        "KA",
+        "KL",
+        "MP",
+        "MH",
+        "MN",
+        "ML",
+        "MZ",
+        "NL",
+        "OD",
+        "PB",
+        "RJ",
+        "SK",
+        "TN",
+        "TG",
+        "TR",
+        "UK",
+        "UP",
+        "WB",
+    )
+
+    union_territories = (
+        ("Andaman and Nicobar Islands",),
+        ("Chandigarh",),
+        ("Dadra and Nagar Haveli, Dadra & Nagar Haveli",),
+        ("Daman and Diu",),
+        ("Delhi, National Capital Territory of Delhi",),
+        ("Jammu and Kashmir",),
+        ("Ladakh",),
+        ("Lakshadweep",),
+        ("Pondicherry",),
+        ("Puducherry",),
+    )
+
+    union_territories_abbr = (
+        "AN",
+        "CH",
+        "DN",
+        "DD",
+        "DL",
+        "JK",
+        "LA",
+        "LD",
+        "PY",
+    )
+
+    # https://en.wikipedia.org/wiki/Postal_Index_Number
+
+    # FIXME: Some states such as `BR/JH` / `UK/UP` have similar PIN code ranges
+    # FIXME: as mentioned in above link.
+
+    state_pincode: Dict[str, List[Range]] = {
+        "AP": [(510_000, 539_999)],
+        "AR": [(790_000, 792_999)],
+        "AS": [(780_000, 789_999)],
+        "BR": [(800_000, 859_999)],
+        "CG": [(490_000, 499_999)],
+        "GA": [(403_000, 403_999)],
+        "GJ": [(360_000, 399_999)],
+        "HR": [(120_000, 139_999)],
+        "HP": [(170_000, 179_999)],
+        "JH": [(800_000, 859_999)],
+        "KA": [(560_000, 599_999)],
+        "KL": [(670_000, 681_999), (683_000, 699_999)],
+        "MP": [(450_000, 489_999)],
+        "MH": [(400_000, 402_999), (404_000, 449_999)],
+        "MN": [(795_000, 795_999)],
+        "ML": [(793_000, 794_999)],
+        "MZ": [(796_000, 796_999)],
+        "NL": [(797_000, 798_999)],
+        "OD": [(750_000, 779_999)],
+        "PB": [(140_000, 159_999)],
+        "RJ": [(300_000, 349_999)],
+        "SK": [(737_000, 737_999)],
+        "TN": [(600_000, 669_999)],
+        "TG": [(500_000, 509_999)],
+        "TR": [(799_000, 799_999)],
+        "UK": [(200_000, 289_999)],
+        "UP": [(200_000, 289_999)],
+        "WB": [(700_000, 736_999), (738_000, 743_999), (745_000, 749_999)],
+    }
+
+    union_territories_pincode: Dict[str, List[Range]] = {
+        "AN": [(744_000, 744_999)],
+        "CH": [(160_000, 169_999)],
+        "DN": [(396_000, 396_999)],
+        "DD": [(396_000, 396_999)],
+        "DL": [(110_000, 119_999)],
+        "JK": [(180_000, 199_999)],
+        "LA": [(180_000, 199_999)],
+        "LD": [(682_000, 682_999)],
+        "PY": [(605_000, 605_999)],
+    }
+
+    army_pincode: Dict[str, Range] = {"APS": (900_000, 999_999)}
+
+    def city_name(self) -> str:
+        return self.random_element(self.cities)
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.states)
+
+    state = administrative_unit
+
+    def union_territory(self) -> str:
+        """Returns random union territory name"""
+
+        return self.random_element(self.union_territories)[0]
+
+    def pincode_in_state(self, state_abbr: Optional[str] = None, include_union_territories: bool = False) -> int:
+        """Random PIN Code within provided state abbreviation
+
+        :param state_abbr: State Abbr, defaults to None
+        :param include_union_territories: Include Union Territories ?, defaults to False
+        :raises ValueError: If incorrect state abbr
+        :return: PIN Code
+        """
+
+        known_abbrs = self.states_abbr
+        if include_union_territories:
+            known_abbrs += self.union_territories_abbr
+
+        if state_abbr is None:
+            state_abbr = self.random_element(known_abbrs)
+
+        if state_abbr in known_abbrs:
+            codes = self.state_pincode
+            if include_union_territories:
+                codes.update(self.union_territories_pincode)
+
+            pincode_range = self.random_element(codes[state_abbr])
+
+            return self.generator.random.randint(*pincode_range)
+
+        raise ValueError("State Abbreviation not found in list")
+
+    def pincode_in_military(self) -> int:
+        """Random PIN Code within Army Postal Service range"""
+
+        key: str = self.random_element(self.army_pincode.keys())
+
+        return self.generator.random.randint(*self.army_pincode[key])
+
+    # Aliases
+
+    def zipcode_in_state(self, state_abbr: Optional[str] = None, include_union_territories: bool = False) -> int:
+        return self.pincode_in_state(state_abbr, include_union_territories)
+
+    def postcode_in_state(self, state_abbr: Optional[str] = None, include_union_territories: bool = False) -> int:
+        return self.pincode_in_state(state_abbr, include_union_territories)
+
+    def pincode_in_army(self) -> int:
+        return self.pincode_in_military()
+
+    def zipcode_in_military(self) -> int:
+        return self.pincode_in_military()
+
+    def zipcode_in_army(self) -> int:
+        return self.pincode_in_military()
+
+    def postcode_in_military(self) -> int:
+        return self.pincode_in_military()
+
+    def postcode_in_army(self) -> int:
+        return self.pincode_in_military()

.venv/lib/python3.12/site-packages/faker/providers/address/en_MS/__init__.py

@@ -0,0 +1,486 @@
+from collections import OrderedDict
+from typing import Dict, List, Optional
+
+from ... import ElementsType
+from ..en import Provider as AddressProvider
+
+# https://en.wikipedia.org/wiki/Addresses_in_Malaysia
+
+
+class Provider(AddressProvider):
+    # 'Bandar' and 'Taman' are the most common township prefix
+    # https://en.wikipedia.org/wiki/Template:Greater_Kuala_Lumpur > Townships
+    # https://en.wikipedia.org/wiki/Template:Johor > Townships
+    # https://en.wikipedia.org/wiki/Template:Kedah > Townships
+    # https://en.wikipedia.org/wiki/Template:Kelantan > Townships
+    # https://en.wikipedia.org/wiki/Template:Melaka > Townships
+    # https://en.wikipedia.org/wiki/Template:Negeri_Sembilan > Townships
+    # https://en.wikipedia.org/wiki/Template:Perak > Townships
+    # https://en.wikipedia.org/wiki/Template:Penang > Townships
+    # https://en.wikipedia.org/wiki/Template:Selangor > Townships
+    # https://en.wikipedia.org/wiki/Template:Terengganu > Townships
+
+    city_prefixes = (
+        "Alam",
+        "Apartment",
+        "Ara",
+        "Bandar",
+        "Bandar",
+        "Bandar",
+        "Bandar",
+        "Bandar",
+        "Bandar",
+        "Bandar Bukit",
+        "Bandar Seri",
+        "Bandar Sri",
+        "Bandar Baru",
+        "Batu",
+        "Bukit",
+        "Desa",
+        "Damansara",
+        "Kampung",
+        "Kampung Baru",
+        "Kampung Baru",
+        "Kondominium",
+        "Kota",
+        "Laman",
+        "Lembah",
+        "Medan",
+        "Pandan",
+        "Pangsapuri",
+        "Petaling",
+        "Puncak",
+        "Seri",
+        "Sri",
+        "Taman",
+        "Taman",
+        "Taman",
+        "Taman",
+        "Taman",
+        "Taman",
+        "Taman Desa",
+    )
+
+    city_suffixes = (
+        "Aman",
+        "Amanjaya",
+        "Anggerik",
+        "Angkasa",
+        "Antarabangsa",
+        "Awan",
+        "Bahagia",
+        "Bangsar",
+        "Baru",
+        "Belakong",
+        "Bendahara",
+        "Bestari",
+        "Bintang",
+        "Brickfields",
+        "Casa",
+        "Changkat",
+        "Country Heights",
+        "Damansara",
+        "Damai",
+        "Dato Harun",
+        "Delima",
+        "Duta",
+        "Flora",
+        "Gembira",
+        "Genting",
+        "Harmoni",
+        "Hartamas",
+        "Impian",
+        "Indah",
+        "Intan",
+        "Jasa",
+        "Jaya",
+        "Keramat",
+        "Kerinchi",
+        "Kiara",
+        "Kinrara",
+        "Kuchai",
+        "Laksamana",
+        "Mahkota",
+        "Maluri",
+        "Manggis",
+        "Maxwell",
+        "Medan",
+        "Melawati",
+        "Menjalara",
+        "Meru",
+        "Mulia",
+        "Mutiara",
+        "Pahlawan",
+        "Perdana",
+        "Pertama",
+        "Permai",
+        "Pelangi",
+        "Petaling",
+        "Pinang",
+        "Puchong",
+        "Puteri",
+        "Putra",
+        "Rahman",
+        "Rahmat",
+        "Raya",
+        "Razak",
+        "Ria",
+        "Saujana",
+        "Segambut",
+        "Selamat",
+        "Selatan",
+        "Semarak",
+        "Sentosa",
+        "Seputeh",
+        "Setapak",
+        "Setia Jaya",
+        "Sinar",
+        "Sungai Besi",
+        "Sungai Buaya",
+        "Sungai Long",
+        "Suria",
+        "Tasik Puteri",
+        "Tengah",
+        "Timur",
+        "Tinggi",
+        "Tropika",
+        "Tun Hussein Onn",
+        "Tun Perak",
+        "Tunku",
+        "Ulu",
+        "Utama",
+        "Utara",
+        "Wangi",
+    )
+
+    # https://en.wikipedia.org/wiki/States_and_federal_territories_of_Malaysia
+    states: Dict[str, List[str]] = {
+        "JHR": ["Johor Darul Ta'zim", "Johor"],
+        "KDH": ["Kedah Darul Aman", "Kedah"],
+        "KTN": ["Kelantan Darul Naim", "Kelantan"],
+        "KUL": ["KL", "Kuala Lumpur", "WP Kuala Lumpur"],
+        "LBN": ["Labuan"],
+        "MLK": ["Malacca", "Melaka"],
+        "NSN": ["Negeri Sembilan Darul Khusus", "Negeri Sembilan"],
+        "PHG": ["Pahang Darul Makmur", "Pahang"],
+        "PNG": ["Penang", "Pulau Pinang"],
+        "PRK": ["Perak Darul Ridzuan", "Perak"],
+        "PLS": ["Perlis Indera Kayangan", "Perlis"],
+        "PJY": ["Putrajaya"],
+        "SBH": ["Sabah"],
+        "SWK": ["Sarawak"],
+        "SGR": ["Selangor Darul Ehsan", "Selangor"],
+        "TRG": ["Terengganu Darul Iman", "Terengganu"],
+    }
+
+    states_postcode = {
+        "PLS": [(1000, 2800)],
+        "KDH": [(5000, 9810)],
+        "PNG": [(10000, 14400)],
+        "KTN": [(15000, 18500)],
+        "TRG": [(20000, 24300)],
+        "PHG": [
+            (25000, 28800),
+            (39000, 39200),
+            (49000, 69000),
+        ],
+        "PRK": [(30000, 36810)],
+        "SGR": [(40000, 48300), (63000, 68100)],
+        "KUL": [(50000, 60000)],
+        "PJY": [(62000, 62988)],
+        "NSN": [(70000, 73509)],
+        "MLK": [(75000, 78309)],
+        "JHR": [(79000, 86900)],
+        "LBN": [(87000, 87033)],
+        "SBH": [(88000, 91309)],
+        "SWK": [(93000, 98859)],
+    }
+
+    city_prefix_abbrs: ElementsType[str] = (
+        "SS",
+        "Seksyen ",
+        "PJS",
+        "PJU",
+        "USJ ",
+    )
+
+    def city_prefix_abbr(self) -> str:
+        return self.random_element(self.city_prefix_abbrs)
+
+    city_formats: ElementsType[str] = (
+        "{{city_prefix}} {{city_suffix}}",
+        "{{city_prefix}} {{city_suffix}}",
+        "{{city_prefix}} {{city_suffix}}",
+        "{{city_prefix}} {{city_suffix}}",
+        "{{city_prefix}} {{city_suffix}}",
+        "{{city_prefix}} {{city_suffix}}",
+        "{{city_prefix_abbr}}%",
+        "{{city_prefix_abbr}}%#",
+        "{{city_prefix_abbr}}%#?",
+    )
+
+    def city(self) -> str:
+        pattern: str = self.bothify(self.random_element(self.city_formats))
+        return self.generator.parse(pattern)
+
+    # https://en.wikipedia.org/wiki/List_of_roads_in_Kuala_Lumpur#Standard_translations
+    street_prefixes: ElementsType[str] = [
+        "Jln",
+        "Jln",
+        "Jalan",
+        "Jalan",
+        "Jalan",
+        "Lorong",
+    ]
+
+    def street_prefix(self) -> str:
+        return self.random_element(self.street_prefixes)
+
+    # https://en.wikipedia.org/wiki/List_of_roads_in_Kuala_Lumpur
+    # https://en.wikipedia.org/wiki/List_of_roads_in_Ipoh
+    # https://en.wikipedia.org/wiki/Transportation_in_Seremban#Inner_city_roads
+    # https://en.wikipedia.org/wiki/List_of_streets_in_George_Town,_Penang
+    street_suffixes: ElementsType[str] = [
+        "Air Itam",
+        "Alor",
+        "Ampang",
+        "Ampang Hilir",
+        "Anson",
+        "Ariffin",
+        "Bangsar",
+        "Baru",
+        "Bellamy",
+        "Birch",
+        "Bijih Timah",
+        "Bukit Aman",
+        "Bukit Bintang",
+        "Bukit Petaling",
+        "Bukit Tunku",
+        "Cantonment",
+        "Cenderawasih",
+        "Chan Sow Lin",
+        "Chow Kit",
+        "Cinta",
+        "Cochrane",
+        "Conlay",
+        "D. S. Ramanathan",
+        "Damansara",
+        "Dang Wangi",
+        "Davis",
+        "Dewan Bahasa",
+        "Dato Abdul Rahman",
+        "Dato'Keramat",
+        "Dato' Maharaja Lela",
+        "Doraisamy",
+        "Eaton",
+        "Faraday",
+        "Galloway",
+        "Genting Klang",
+        "Gereja",
+        "Hang Jebat",
+        "Hang Kasturi",
+        "Hang Lekir",
+        "Hang Lekiu",
+        "Hang Tuah",
+        "Hospital",
+        "Imbi",
+        "Istana",
+        "Jelutong",
+        "Kampung Attap",
+        "Kebun Bunga",
+        "Kedah",
+        "Keliling",
+        "Kia Peng",
+        "Kinabalu",
+        "Kuala Kangsar",
+        "Kuching",
+        "Ledang",
+        "Lembah Permai",
+        "Loke Yew",
+        "Lt. Adnan",
+        "Lumba Kuda",
+        "Madras",
+        "Magazine",
+        "Maharajalela",
+        "Masjid",
+        "Maxwell",
+        "Mohana Chandran",
+        "Muda",
+        "P. Ramlee",
+        "Padang Kota Lama",
+        "Pahang",
+        "Pantai Baharu",
+        "Parlimen",
+        "Pasar",
+        "Pasar Besar",
+        "Perak",
+        "Perdana",
+        "Petaling",
+        "Prangin",
+        "Pudu",
+        "Pudu Lama",
+        "Raja",
+        "Raja Abdullah",
+        "Raja Chulan",
+        "Raja Laut",
+        "Rakyat",
+        "Residensi",
+        "Robson",
+        "S.P. Seenivasagam",
+        "Samarahan 1",
+        "Selamat",
+        "Sempadan",
+        "Sentul",
+        "Serian 1",
+        "Sasaran",
+        "Sin Chee",
+        "Sultan Abdul Samad",
+        "Sultan Azlan Shah",
+        "Sultan Iskandar",
+        "Sultan Ismail",
+        "Sultan Sulaiman",
+        "Sungai Besi",
+        "Syed Putra",
+        "Tan Cheng Lock",
+        "Thambipillay",
+        "Tugu",
+        "Tuanku Abdul Halim",
+        "Tuanku Abdul Rahman",
+        "Tun Abdul Razak",
+        "Tun Dr Ismail",
+        "Tun H S Lee",
+        "Tun Ismail",
+        "Tun Perak",
+        "Tun Razak",
+        "Tun Sambanthan",
+        "U-Thant",
+        "Utama",
+        "Vermont",
+        "Vivekananda",
+        "Wan Kadir",
+        "Wesley",
+        "Wisma Putra",
+        "Yaacob Latif",
+        "Yap Ah Loy",
+        "Yap Ah Shak",
+        "Yap Kwan Seng",
+        "Yew",
+        "Zaaba",
+        "Zainal Abidin",
+    ]
+
+    street_name_formats: ElementsType[str] = (
+        "{{street_prefix}} %",
+        "{{street_prefix}} %/%",
+        "{{street_prefix}} %/%#",
+        "{{street_prefix}} %/%?",
+        "{{street_prefix}} %/%#?",
+        "{{street_prefix}} %?",
+        "{{street_prefix}} %#?",
+        "{{street_prefix}} {{street_suffix}}",
+        "{{street_prefix}} {{street_suffix}} %",
+        "{{street_prefix}} {{street_suffix}} %/%",
+        "{{street_prefix}} {{street_suffix}} %/%#",
+        "{{street_prefix}} {{street_suffix}} %/%?",
+        "{{street_prefix}} {{street_suffix}} %/%#?",
+        "{{street_prefix}} {{street_suffix}} %?",
+        "{{street_prefix}} {{street_suffix}} %#?",
+    )
+
+    def street_name(self) -> str:
+        """
+        :example: 'Crist Parks'
+        """
+        pattern: str = self.bothify(self.random_element(self.street_name_formats))
+        return self.generator.parse(pattern)
+
+    building_prefixes: ElementsType[str] = [
+        "",
+        "",
+        "",
+        "",
+        "",
+        "",
+        "No. ",
+        "No. ",
+        "No. ",
+        "Lot ",
+    ]
+
+    def building_prefix(self) -> str:
+        return self.random_element(self.building_prefixes)
+
+    building_number_formats: ElementsType[str] = (
+        "%",
+        "%",
+        "%",
+        "%#",
+        "%#",
+        "%#",
+        "%#",
+        "%##",
+        "%-%",
+        "?-##-##",
+        "%?-##",
+    )
+
+    def building_number(self) -> str:
+        return self.bothify(self.random_element(self.building_number_formats))
+
+    street_address_formats: ElementsType[str] = ("{{building_prefix}}{{building_number}}, {{street_name}}",)
+
+    def city_state(self) -> str:
+        """Return the complete city address with matching postcode and state
+
+        Example: 55100 Bukit Bintang, Kuala Lumpur
+        """
+        state: str = self.random_element(self.states.keys())
+        postcode = self.postcode_in_state(state)
+        city = self.city()
+        state_name: str = self.random_element(self.states[state])
+
+        return f"{postcode} {city}, {state_name}"
+
+    # https://en.wikipedia.org/wiki/Addresses_in_Malaysia
+    # street number, street name, region, and town/city, state.
+    address_formats = OrderedDict((("{{street_address}}, {{city}}, {{city_state}}", 100.0),))
+
+    def city_prefix(self) -> str:
+        return self.random_element(self.city_prefixes)
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.states[self.random_element(self.states.keys())])
+
+    state = administrative_unit
+
+    def postcode_in_state(self, state_abbr: Optional[str] = None) -> str:
+        """
+        :returns: A random postcode within the provided state
+
+        :param state: A state
+
+        Example: 55100
+        https://en.wikipedia.org/wiki/Postal_codes_in_Malaysia#States
+        """
+
+        if state_abbr is None:
+            state_abbr = self.random_element(self.states.keys())
+
+        try:
+            # some states have multiple ranges so first pick one, then generate a random postcode
+            range = self.generator.random.choice(self.states_postcode[state_abbr])
+            postcode = "%d" % (self.generator.random.randint(*range))
+
+            # zero left pad up until desired length (some have length 3 or 4)
+            target_postcode_len = 5
+            current_postcode_len = len(postcode)
+            if current_postcode_len < target_postcode_len:
+                pad = target_postcode_len - current_postcode_len
+                postcode = f"{'0'*pad}{postcode}"
+
+            return postcode
+        except KeyError as e:
+            raise KeyError("State Abbreviation not found in list") from e
+
+    def postcode(self) -> str:
+        return self.postcode_in_state(None)

.venv/lib/python3.12/site-packages/faker/providers/address/en_NZ/__init__.py

@@ -0,0 +1,340 @@
+from ..en import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_prefixes = (
+        "North",
+        "East",
+        "West",
+        "South",
+        "New",
+        "Lake",
+        "Port",
+        "Upper",
+        "Lower",
+        "High",
+        "Mount",
+    )
+
+    city_suffixes = (
+        "town",
+        "ton",
+        "land",
+        "ville",
+        "berg",
+        "burgh",
+        "borough",
+        "bury",
+        "burn",
+        "ing",
+        "port",
+        "mouth",
+        "stone",
+        "ings",
+        "mouth",
+        "fort",
+        "haven",
+        "leigh",
+        "side",
+        "gate",
+        "neath",
+        "side",
+        " Flats",
+        " Hill",
+    )
+
+    building_number_formats = ("%##", "%#", "%")
+
+    street_suffixes = (
+        # Most common:
+        "Arcade",
+        "Arcade",
+        "Arcade",
+        "Avenue",
+        "Avenue",
+        "Avenue",
+        "Avenue",
+        "Avenue",
+        "Avenue",
+        "Avenue",
+        "Avenue",
+        "Beach Road",
+        "Beach Road",
+        "Beach Road",
+        "Beach Road",
+        "Crescent",
+        "Crescent",
+        "Crescent",
+        "Crescent",
+        "Crescent",
+        "Drive",
+        "Drive",
+        "Drive",
+        "Drive",
+        "Mews",
+        "Mews",
+        "Mews",
+        "Place",
+        "Place",
+        "Place",
+        "Place",
+        "Range Road",
+        "Range Road",
+        "Road",
+        "Road",
+        "Road",
+        "Road",
+        "Road",
+        "Road",
+        "Road",
+        "Road",
+        "Road",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Street",
+        "Terrace",
+        "Terrace",
+        "Terrace",
+        "Way",
+        "Way",
+        "Way",
+        # Other:
+        "Access",
+        "Alley",
+        "Alleyway",
+        "Amble",
+        "Anchorage",
+        "Approach",
+        "Broadway",
+        "Bypass",
+        "Causeway",
+        "Centre",
+        "Circle",
+        "Circuit",
+        "Close",
+        "Concourse",
+        "Copse",
+        "Corner",
+        "Court",
+        "Cove",
+        "Crest",
+        "Cross",
+        "Crossing",
+        "Cutting",
+        "Esplanade",
+        "Flats",
+        "Gardens",
+        "Grove",
+        "Heights",
+        "Highway",
+        "Lane",
+        "Line",
+        "Keys",
+        "Parade",
+        "Park",
+        "Pass",
+        "Plaza",
+        "Point",
+        "Quay",
+        "Reserve",
+        "Ridge",
+        "Rise",
+        "Square",
+        "Track",
+        "Trail",
+        "View",
+    )
+
+    # Māori nouns commonly present in placenames.
+    te_reo_parts = (
+        "ara",
+        "awa",
+        "horo",
+        "kawa",
+        "koro",
+        "kowhai",
+        "manawa",
+        "mata",
+        "maunga",
+        "moko",
+        "motu",
+        "ngauru",
+        "pa" "papa",
+        "po",
+        "puke",
+        "rangi",
+        "rohe",
+        "rongo",
+        "roto",
+        "tahi",
+        "tai",
+        "tangi",
+        "tau",
+        "tere",
+        "tipu",
+        "wai",
+        "waka",
+        "whaka",
+        "whanga",
+        "whare",
+        "weka",
+    )
+
+    # Māori endings (usually adjectives) commonly present in placenames.
+    te_reo_endings = (
+        "hanga",
+        "hope",
+        "iti",
+        "iti",
+        "kiwi",
+        "makau",
+        "nui",
+        "nui",
+        "nui",
+        "nuku",
+        "roa",
+        "rua",
+        "tanga",
+        "tapu",
+        "toa",
+        "whenua",
+        "whero",
+        "whitu",
+    )
+
+    postcode_formats = (
+        # as per https://en.wikipedia.org/wiki/Postcodes_in_New_Zealand
+        # Northland
+        "0%##",
+        # Auckland
+        "1###",
+        "20##",
+        "21##",
+        "22##",
+        "23##",
+        "24##",
+        "25##",
+        "26##",
+        # Central North Island
+        "3###",
+        "4###",
+        # Lower North Island
+        "50##",
+        "51##",
+        "52##",
+        "53##",
+        "55##",
+        "57##",
+        "58##",
+        # Wellington
+        "60##",
+        "61##",
+        "62##",
+        "64##",
+        "69##",
+        # Upper South Island
+        "7###",
+        # Christchurch
+        "80##",
+        "81##",
+        "82##",
+        "84##",
+        "85##",
+        "86##",
+        "88##",
+        "89##",
+        # Southland
+        "90##",
+        "92##",
+        "93##",
+        "94##",
+        "95##",
+        "96##",
+        "97##",
+        "98##",
+    )
+
+    city_formats = (
+        "{{first_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+        "{{city_prefix}} {{last_name}}{{city_suffix}}",
+        "{{te_reo_first}}{{te_reo_ending}}",
+        "{{te_reo_first}}{{te_reo_ending}}",
+        "{{te_reo_first}}{{te_reo_ending}}",
+        "{{te_reo_first}}{{te_reo_ending}}",
+        "{{te_reo_first}}{{te_reo_part}}{{te_reo_ending}}",
+        "{{te_reo_first}}{{te_reo_part}}{{te_reo_ending}}",
+    )
+
+    street_name_formats = (
+        "{{first_name}} {{street_suffix}}",
+        "{{last_name}} {{street_suffix}}",
+        "{{last_name}} {{street_suffix}}",
+        "{{last_name}} {{street_suffix}}",
+        "{{last_name}}-{{last_name}} {{street_suffix}}",
+        "{{te_reo_first}}{{te_reo_ending}} {{street_suffix}}",
+        "{{te_reo_first}}{{te_reo_ending}} {{street_suffix}}",
+        "{{te_reo_first}}{{te_reo_part}}{{te_reo_ending}} {{street_suffix}}",
+    )
+
+    street_address_formats = (
+        "{{building_number}} {{street_name}}",
+        "{{building_number}} {{street_name}}",
+        "{{building_number}} {{street_name}}",
+        "{{building_number}} {{street_name}}\nRD {{rd_number}}",
+        "{{secondary_address}}\n{{building_number}} {{street_name}}",
+        "PO Box {{building_number}}",
+    )
+
+    address_formats = ("{{street_address}}\n{{city}} {{postcode}}",)
+
+    secondary_address_formats = (
+        "Apt. %##",
+        "Flat %#",
+        "Suite %##",
+        "Unit %#",
+        "Level %",
+    )
+
+    def te_reo_part(self) -> str:
+        return self.random_element(self.te_reo_parts)
+
+    def te_reo_first(self) -> str:
+        return str(self.random_element(self.te_reo_parts)).capitalize()
+
+    def te_reo_ending(self) -> str:
+        return self.random_element(self.te_reo_parts + self.te_reo_endings)
+
+    def city_prefix(self) -> str:
+        return self.random_element(self.city_prefixes)
+
+    def city_suffix(self) -> str:
+        return self.random_element(self.city_suffixes)
+
+    def rd_number(self) -> str:
+        return self.random_element([str(i) for i in range(1, 11)])
+
+    def secondary_address(self) -> str:
+        return self.numerify(self.random_element(self.secondary_address_formats))

.venv/lib/python3.12/site-packages/faker/providers/address/en_US/__init__.py

@@ -0,0 +1,599 @@
+from collections import OrderedDict
+from typing import Optional, Tuple
+
+from ..en import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_prefixes = ("North", "East", "West", "South", "New", "Lake", "Port")
+
+    city_suffixes = (
+        "town",
+        "ton",
+        "land",
+        "ville",
+        "berg",
+        "burgh",
+        "borough",
+        "bury",
+        "view",
+        "port",
+        "mouth",
+        "stad",
+        "furt",
+        "chester",
+        "mouth",
+        "fort",
+        "haven",
+        "side",
+        "shire",
+    )
+
+    building_number_formats = ("#####", "####", "###")
+
+    street_suffixes = (
+        "Alley",
+        "Avenue",
+        "Branch",
+        "Bridge",
+        "Brook",
+        "Brooks",
+        "Burg",
+        "Burgs",
+        "Bypass",
+        "Camp",
+        "Canyon",
+        "Cape",
+        "Causeway",
+        "Center",
+        "Centers",
+        "Circle",
+        "Circles",
+        "Cliff",
+        "Cliffs",
+        "Club",
+        "Common",
+        "Corner",
+        "Corners",
+        "Course",
+        "Court",
+        "Courts",
+        "Cove",
+        "Coves",
+        "Creek",
+        "Crescent",
+        "Crest",
+        "Crossing",
+        "Crossroad",
+        "Curve",
+        "Dale",
+        "Dam",
+        "Divide",
+        "Drive",
+        "Drive",
+        "Drives",
+        "Estate",
+        "Estates",
+        "Expressway",
+        "Extension",
+        "Extensions",
+        "Fall",
+        "Falls",
+        "Ferry",
+        "Field",
+        "Fields",
+        "Flat",
+        "Flats",
+        "Ford",
+        "Fords",
+        "Forest",
+        "Forge",
+        "Forges",
+        "Fork",
+        "Forks",
+        "Fort",
+        "Freeway",
+        "Garden",
+        "Gardens",
+        "Gateway",
+        "Glen",
+        "Glens",
+        "Green",
+        "Greens",
+        "Grove",
+        "Groves",
+        "Harbor",
+        "Harbors",
+        "Haven",
+        "Heights",
+        "Highway",
+        "Hill",
+        "Hills",
+        "Hollow",
+        "Inlet",
+        "Inlet",
+        "Island",
+        "Island",
+        "Islands",
+        "Islands",
+        "Isle",
+        "Isle",
+        "Junction",
+        "Junctions",
+        "Key",
+        "Keys",
+        "Knoll",
+        "Knolls",
+        "Lake",
+        "Lakes",
+        "Land",
+        "Landing",
+        "Lane",
+        "Light",
+        "Lights",
+        "Loaf",
+        "Lock",
+        "Locks",
+        "Locks",
+        "Lodge",
+        "Lodge",
+        "Loop",
+        "Mall",
+        "Manor",
+        "Manors",
+        "Meadow",
+        "Meadows",
+        "Mews",
+        "Mill",
+        "Mills",
+        "Mission",
+        "Mission",
+        "Motorway",
+        "Mount",
+        "Mountain",
+        "Mountain",
+        "Mountains",
+        "Mountains",
+        "Neck",
+        "Orchard",
+        "Oval",
+        "Overpass",
+        "Park",
+        "Parks",
+        "Parkway",
+        "Parkways",
+        "Pass",
+        "Passage",
+        "Path",
+        "Pike",
+        "Pine",
+        "Pines",
+        "Place",
+        "Plain",
+        "Plains",
+        "Plains",
+        "Plaza",
+        "Plaza",
+        "Point",
+        "Points",
+        "Port",
+        "Port",
+        "Ports",
+        "Ports",
+        "Prairie",
+        "Prairie",
+        "Radial",
+        "Ramp",
+        "Ranch",
+        "Rapid",
+        "Rapids",
+        "Rest",
+        "Ridge",
+        "Ridges",
+        "River",
+        "Road",
+        "Road",
+        "Roads",
+        "Roads",
+        "Route",
+        "Row",
+        "Rue",
+        "Run",
+        "Shoal",
+        "Shoals",
+        "Shore",
+        "Shores",
+        "Skyway",
+        "Spring",
+        "Springs",
+        "Springs",
+        "Spur",
+        "Spurs",
+        "Square",
+        "Square",
+        "Squares",
+        "Squares",
+        "Station",
+        "Station",
+        "Stravenue",
+        "Stravenue",
+        "Stream",
+        "Stream",
+        "Street",
+        "Street",
+        "Streets",
+        "Summit",
+        "Summit",
+        "Terrace",
+        "Throughway",
+        "Trace",
+        "Track",
+        "Trafficway",
+        "Trail",
+        "Trail",
+        "Tunnel",
+        "Tunnel",
+        "Turnpike",
+        "Turnpike",
+        "Underpass",
+        "Union",
+        "Unions",
+        "Valley",
+        "Valleys",
+        "Via",
+        "Viaduct",
+        "View",
+        "Views",
+        "Village",
+        "Village",
+        "Villages",
+        "Ville",
+        "Vista",
+        "Vista",
+        "Walk",
+        "Walks",
+        "Wall",
+        "Way",
+        "Ways",
+        "Well",
+        "Wells",
+    )
+
+    postcode_formats = ("#####", "#####-####")
+
+    states = (
+        "Alabama",
+        "Alaska",
+        "Arizona",
+        "Arkansas",
+        "California",
+        "Colorado",
+        "Connecticut",
+        "Delaware",
+        "Florida",
+        "Georgia",
+        "Hawaii",
+        "Idaho",
+        "Illinois",
+        "Indiana",
+        "Iowa",
+        "Kansas",
+        "Kentucky",
+        "Louisiana",
+        "Maine",
+        "Maryland",
+        "Massachusetts",
+        "Michigan",
+        "Minnesota",
+        "Mississippi",
+        "Missouri",
+        "Montana",
+        "Nebraska",
+        "Nevada",
+        "New Hampshire",
+        "New Jersey",
+        "New Mexico",
+        "New York",
+        "North Carolina",
+        "North Dakota",
+        "Ohio",
+        "Oklahoma",
+        "Oregon",
+        "Pennsylvania",
+        "Rhode Island",
+        "South Carolina",
+        "South Dakota",
+        "Tennessee",
+        "Texas",
+        "Utah",
+        "Vermont",
+        "Virginia",
+        "Washington",
+        "West Virginia",
+        "Wisconsin",
+        "Wyoming",
+    )
+    states_abbr = (
+        "AL",
+        "AK",
+        "AZ",
+        "AR",
+        "CA",
+        "CO",
+        "CT",
+        "DE",
+        "DC",
+        "FL",
+        "GA",
+        "HI",
+        "ID",
+        "IL",
+        "IN",
+        "IA",
+        "KS",
+        "KY",
+        "LA",
+        "ME",
+        "MD",
+        "MA",
+        "MI",
+        "MN",
+        "MS",
+        "MO",
+        "MT",
+        "NE",
+        "NV",
+        "NH",
+        "NJ",
+        "NM",
+        "NY",
+        "NC",
+        "ND",
+        "OH",
+        "OK",
+        "OR",
+        "PA",
+        "RI",
+        "SC",
+        "SD",
+        "TN",
+        "TX",
+        "UT",
+        "VT",
+        "VA",
+        "WA",
+        "WV",
+        "WI",
+        "WY",
+    )
+
+    states_postcode = {
+        "AL": (35004, 36925),
+        "AK": (99501, 99950),
+        "AZ": (85001, 86556),
+        "AR": (71601, 72959),
+        "CA": (90001, 96162),
+        "CO": (80001, 81658),
+        "CT": (6001, 6389),
+        "DE": (19701, 19980),
+        "DC": (20001, 20039),
+        "FL": (32004, 34997),
+        "GA": (30001, 31999),
+        "HI": (96701, 96898),
+        "ID": (83201, 83876),
+        "IL": (60001, 62999),
+        "IN": (46001, 47997),
+        "IA": (50001, 52809),
+        "KS": (66002, 67954),
+        "KY": (40003, 42788),
+        "LA": (70001, 71232),
+        "ME": (3901, 4992),
+        "MD": (20812, 21930),
+        "MA": (1001, 2791),
+        "MI": (48001, 49971),
+        "MN": (55001, 56763),
+        "MS": (38601, 39776),
+        "MO": (63001, 65899),
+        "MT": (59001, 59937),
+        "NE": (68001, 68118),
+        "NV": (88901, 89883),
+        "NH": (3031, 3897),
+        "NJ": (7001, 8989),
+        "NM": (87001, 88441),
+        "NY": (10001, 14905),
+        "NC": (27006, 28909),
+        "ND": (58001, 58856),
+        "OH": (43001, 45999),
+        "OK": (73001, 73199),
+        "OR": (97001, 97920),
+        "PA": (15001, 19640),
+        "RI": (2801, 2940),
+        "SC": (29001, 29948),
+        "SD": (57001, 57799),
+        "TN": (37010, 38589),
+        "TX": (75503, 79999),
+        "UT": (84001, 84784),
+        "VT": (5001, 5495),
+        "VA": (22001, 24658),
+        "WA": (98001, 99403),
+        "WV": (24701, 26886),
+        "WI": (53001, 54990),
+        "WY": (82001, 83128),
+        # Territories & freely-associated states
+        # incomplete ranges with accurate subsets - https://www.geonames.org/postalcode-search.html
+        "AS": (96799, 96799),
+        "FM": (96941, 96944),
+        "GU": (96910, 96932),
+        "MH": (96960, 96970),
+        "MP": (96950, 96952),
+        "PW": (96940, 96940),
+        "PR": (600, 799),
+        "VI": (801, 805),
+    }
+
+    territories_abbr = (
+        "AS",
+        "GU",
+        "MP",
+        "PR",
+        "VI",
+    )
+
+    # Freely-associated states (sovereign states; members of COFA)
+    # https://en.wikipedia.org/wiki/Compact_of_Free_Association
+    freely_associated_states_abbr = (
+        "FM",
+        "MH",
+        "PW",
+    )
+
+    known_usps_abbr = states_abbr + territories_abbr + freely_associated_states_abbr
+
+    military_state_abbr = ("AE", "AA", "AP")
+
+    military_ship_prefix = ("USS", "USNS", "USNV", "USCGC")
+
+    military_apo_format = "PSC ####, Box ####"
+
+    military_dpo_format = "Unit #### Box ####"
+
+    city_formats = (
+        "{{city_prefix}} {{first_name}}{{city_suffix}}",
+        "{{city_prefix}} {{first_name}}",
+        "{{first_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+    )
+
+    street_name_formats = (
+        "{{first_name}} {{street_suffix}}",
+        "{{last_name}} {{street_suffix}}",
+    )
+
+    street_address_formats = (
+        "{{building_number}} {{street_name}}",
+        "{{building_number}} {{street_name}} {{secondary_address}}",
+    )
+
+    address_formats = OrderedDict(
+        (
+            ("{{street_address}}\n{{city}}, {{state_abbr}} {{postcode}}", 25.0),
+            #  military address formatting.
+            ("{{military_apo}}\nAPO {{military_state}} {{postcode}}", 1.0),
+            (
+                "{{military_ship}} {{last_name}}\nFPO {{military_state}} {{postcode}}",
+                1.0,
+            ),
+            ("{{military_dpo}}\nDPO {{military_state}} {{postcode}}", 1.0),
+        )
+    )
+
+    secondary_address_formats = ("Apt. ###", "Suite ###")
+
+    def city_prefix(self) -> str:
+        return self.random_element(self.city_prefixes)
+
+    def secondary_address(self) -> str:
+        return self.numerify(self.random_element(self.secondary_address_formats))
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.states)
+
+    state = administrative_unit
+
+    def state_abbr(
+        self,
+        include_territories: bool = True,
+        include_freely_associated_states: bool = True,
+    ) -> 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.
+            If False, sovereign states in free association with the US will be excluded.
+        """
+        abbreviations: Tuple[str, ...] = self.states_abbr
+        if include_territories:
+            abbreviations += self.territories_abbr
+        if include_freely_associated_states:
+            abbreviations += self.freely_associated_states_abbr
+        return self.random_element(abbreviations)
+
+    def postcode(self) -> str:
+        return "%05d" % self.generator.random.randint(501, 99950)
+
+    def zipcode_plus4(self) -> str:
+        return "%s-%04d" % (self.zipcode(), self.generator.random.randint(1, 9999))
+
+    def postcode_in_state(self, state_abbr: Optional[str] = None) -> str:
+        """
+        :returns: A random postcode within the provided state abbreviation
+
+        :param state_abbr: A state abbreviation
+        """
+        if state_abbr is None:
+            state_abbr = self.random_element(self.states_abbr)
+
+        if state_abbr in self.known_usps_abbr:
+            postcode = "%d" % (
+                self.generator.random.randint(
+                    self.states_postcode[state_abbr][0],
+                    self.states_postcode[state_abbr][1],
+                )
+            )
+
+            # zero left pad up until desired length (some have length 3 or 4)
+            target_postcode_len = 5
+            current_postcode_len = len(postcode)
+            if current_postcode_len < target_postcode_len:
+                pad = target_postcode_len - current_postcode_len
+                postcode = f"{'0'*pad}{postcode}"
+
+            return postcode
+
+        else:
+            raise Exception("State Abbreviation not found in list")
+
+    def military_ship(self) -> str:
+        """
+        :example: 'USS'
+        """
+        return self.random_element(self.military_ship_prefix)
+
+    def military_state(self) -> str:
+        """
+        :example: 'APO'
+        """
+        return self.random_element(self.military_state_abbr)
+
+    def military_apo(self) -> str:
+        """
+        :example: 'PSC 5394 Box 3492
+        """
+        return self.numerify(self.military_apo_format)
+
+    def military_dpo(self) -> str:
+        """
+        :example: 'Unit 3333 Box 9342'
+        """
+        return self.numerify(self.military_dpo_format)
+
+    # Aliases
+    def zipcode(self) -> str:
+        return self.postcode()
+
+    def zipcode_in_state(self, state_abbr: Optional[str] = None) -> str:
+        return self.postcode_in_state(state_abbr)
+
+    def postalcode(self) -> str:
+        return self.postcode()
+
+    def postalcode_in_state(self, state_abbr: Optional[str] = None) -> str:
+        return self.postcode_in_state(state_abbr)
+
+    def postalcode_plus4(self) -> str:
+        return self.zipcode_plus4()

.venv/lib/python3.12/site-packages/faker/providers/address/es/__init__.py

@@ -0,0 +1,200 @@
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    # List of Countries https://www.un.org/es/members/
+    countries = (
+        "Afganistán",
+        "Albania",
+        "Alemania",
+        "Andorra",
+        "Angola",
+        "Antigua y Barbuda",
+        "Arabia Saudita",
+        "Argelia",
+        "Argentina",
+        "Armenia",
+        "Australia",
+        "Austria",
+        "Azerbaiyán",
+        "Bahamas",
+        "Bahrein",
+        "Bangladesh",
+        "Barbados",
+        "Belarús",
+        "Bélgica",
+        "Belice",
+        "Benin",
+        "Bhután",
+        "Bolivia",
+        "Bosnia y Herzegovina",
+        "Botswana",
+        "Brasil",
+        "Brunei Darussalam",
+        "Bulgaria",
+        "Burkina Faso",
+        "Burundi",
+        "Cabo Verde",
+        "Camboya",
+        "Camerún",
+        "Canadá",
+        "Chad",
+        "Chile",
+        "China",
+        "Chipre",
+        "Colombia",
+        "Comoras",
+        "Congo",
+        "Costa Rica",
+        "Côte d'Ivoire",
+        "Croacia",
+        "Cuba",
+        "Dinamarca",
+        "Djibouti",
+        "Dominicana",
+        "Ecuador",
+        "Egipto",
+        "El Salvador",
+        "Emiratos Árabes Unidos",
+        "Eritrea",
+        "Eslovaquia",
+        "Eslovenia",
+        "España",
+        "Estados Unidos de América",
+        "Estonia",
+        "Etiopía",
+        "Federación de Rusia",
+        "Fiji",
+        "Filipinas",
+        "Finlandia",
+        "Francia",
+        "Gabón",
+        "Gambia",
+        "Georgia",
+        "Ghana",
+        "Granada",
+        "Grecia",
+        "Guatemala",
+        "Guinea",
+        "Guinea Bissau",
+        "Guinea Ecuatorial",
+        "Guyana",
+        "Haití",
+        "Honduras",
+        "Hungría",
+        "India",
+        "Indonesia",
+        "Irán",
+        "Iraq",
+        "Irlanda",
+        "Islandia",
+        "Islas Marshall",
+        "Islas Salomón",
+        "Israel",
+        "Italia",
+        "Jamaica",
+        "Japón",
+        "Jordania",
+        "Kazajstán",
+        "Kenya",
+        "Kirguistán",
+        "Kiribati",
+        "Kuwait",
+        "Lesotho",
+        "Letonia",
+        "Líbano",
+        "Liberia",
+        "Libia",
+        "Liechtenstein",
+        "Lituania",
+        "Luxemburgo",
+        "Madagascar",
+        "Malasia",
+        "Malawi",
+        "Maldivas",
+        "Mali",
+        "Malta",
+        "Marruecos",
+        "Mauricio",
+        "Mauritania",
+        "México",
+        "Micronesia",
+        "Mónaco",
+        "Mongolia",
+        "Montenegro",
+        "Mozambique",
+        "Myanmar",
+        "Namibia",
+        "Nauru",
+        "Nicaragua",
+        "Niger",
+        "Nigeria",
+        "Noruega",
+        "Nueva Zelandia",
+        "Omán",
+        "Países Bajos",
+        "Pakistán",
+        "Palau",
+        "Panamá",
+        "Papua Nueva Guinea",
+        "Paraguay",
+        "Perú",
+        "Polonia",
+        "Portugal",
+        "Qatar",
+        "Reino Unido de Gran Bretaña e Irlanda del Norte",
+        "República Árabe Siria",
+        "República Centroafricana",
+        "República Checa",
+        "República de Corea",
+        "República de Macedonia del Norte",
+        "República de Moldova",
+        "República Democrática del Congo",
+        "República Democrática Popular Lao",
+        "República Dominicana",
+        "República Federal Democrática de Nepal",
+        "República Popular Democrática de Corea",
+        "República Unida de Tanzanía",
+        "Rumania",
+        "Rwanda",
+        "Saint Kitts y Nevis",
+        "Samoa",
+        "San Marino",
+        "Santa Lucía",
+        "Santo Tomé y Príncipe",
+        "San Vicente y las Granadinas",
+        "Senegal",
+        "Serbia",
+        "Seychelles",
+        "Sierra Leona",
+        "Singapur",
+        "Somalia",
+        "Sri Lanka",
+        "Sudáfrica",
+        "Sudán",
+        "Sudán del Sur",
+        "Suecia",
+        "Suiza",
+        "Suriname",
+        "Swazilandia",
+        "Tailandia",
+        "Tayikistán",
+        "Timor-Leste",
+        "Togo",
+        "Tonga",
+        "Trinidad y Tabago",
+        "Túnez",
+        "Turkmenistán",
+        "Turquía",
+        "Tuvalu",
+        "Ucrania",
+        "Uganda",
+        "Uruguay",
+        "Uzbekistán",
+        "Vanuatu",
+        "Venezuela",
+        "Vietman",
+        "Yemen",
+        "Zambia",
+        "Zimbabwe",
+    )

.venv/lib/python3.12/site-packages/faker/providers/address/es_AR/__init__.py

@@ -0,0 +1,231 @@
+from collections import OrderedDict
+from typing import List, Tuple
+
+from ..es import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    provinces = {
+        "CABA": "Ciudad Autónoma de Buenos Aires",
+        "BA": "Buenos Aires",
+        "CA": "Catamarca",
+        "CH": "Chaco",
+        "CT": "Chubut",
+        "CB": "Córdoba",
+        "CR": "Corrientes",
+        "ER": "Entre Ríos",
+        "FO": "Formosa",
+        "JY": "Jujuy",
+        "LP": "La Pampa",
+        "LR": "La Rioja",
+        "MZ": "Mendoza",
+        "MI": "Misiones",
+        "NQN": "Neuquén",
+        "RN": "Río Negro",
+        "SA": "Salta",
+        "SJ": "San Juan",
+        "SL": "San Luis",
+        "SC": "Santa Cruz",
+        "SF": "Santa Fe",
+        "SE": "Santiago del Estero",
+        "TF": "Tierra del Fuego",
+        "TU": "Tucumán",
+    }
+
+    municipalities: List[Tuple[str, str, str]] = [
+        ("1004", "Constitución", "CABA"),
+        ("1900", "La Plata", "BA"),
+        ("7600", "Mar del Plata", "BA"),
+        ("8000", "Bahía Blanca", "BA"),
+        ("4700", "San Ferando del Valle de Catamarca", "CA"),
+        ("3500", "Resistencia", "CH"),
+        ("9103", "Rawson", "CT"),
+        ("9000", "Comodoro Rivadavia", "CT"),
+        ("5000", "Córdoba", "CB"),
+        ("3400", "Corrientes", "CR"),
+        ("3100", "Paraná", "ER"),
+        ("3600", "Formosa", "FO"),
+        ("4600", "San Salvador de Jujuy", "JY"),
+        ("6300", "Santa Rosa", "LP"),
+        ("5300", "La Rioja", "LR"),
+        ("5360", "Chilecito", "LR"),
+        ("5500", "Mendoza", "MZ"),
+        ("3300", "Posadas", "MI"),
+        ("8300", "Neuquén", "NQN"),
+        ("8500", "Viedma", "RN"),
+        ("4400", "Salta", "SA"),
+        ("5400", "San Juan", "SJ"),
+        ("5700", "San Luis", "SL"),
+        ("5881", "Merlo", "SL"),
+        ("9400", "Río Gallegos", "SC"),
+        ("3000", "Santa Fe", "SF"),
+        ("2000", "Rosario", "SF"),
+        ("4200", "Santiago del Estero", "SE"),
+        ("9410", "Ushuaia", "TF"),
+        ("4000", "San Miguel de Tucumán", "TU"),
+    ]
+
+    street_prefixes = OrderedDict(
+        [
+            ("Calle", 0.2),
+            ("Avenida", 0.2),
+            ("Av.", 0.2),
+            ("Diagonal", 0.2),
+            ("Diag.", 0.05),
+            ("Camino", 0.05),
+            ("Boulevard", 0.05),
+            ("Blv.", 0.05),
+        ]
+    )
+    street_suffixes = ["A", "B", "Bis"]
+
+    street_proceres = (
+        "San Martin",
+        "Belgrano",
+        "Saavedra",
+        "Rivadavia",
+        "Güemes",
+        "G. Brown",
+        "J.B. Alberdi",
+        "J.M. de Rosas",
+        "J.J. Castelli",
+        "Mitre",
+        "Alem",
+        "Alvear",
+        "Malvinas Argentinas",
+        "Pte. Perón",
+        "Omar Nuñez",
+    )
+    street_name_formats = OrderedDict(
+        [
+            ("{{street_prefix}} %", 0.2),
+            ("{{street_prefix}} {{street_municipality}}", 0.2),
+            ("{{street_prefix}} {{street_province}}", 0.2),
+            ("{{street_prefix}} {{street_procer}}", 0.2),
+            ("{{street_prefix}} 1## {{street_suffix}}", 0.02),
+        ]
+    )
+    building_number_formats = OrderedDict(
+        [
+            ("%%", 0.2),
+            ("%%#", 0.2),
+            ("%#%", 0.2),
+            ("%#%#", 0.2),
+        ]
+    )
+    secondary_address_formats = [
+        "Piso % Dto. %",
+        "Dto. %",
+        "Torre % Dto. %",
+        "Local %!",
+        "Oficina %!",
+    ]
+    postcode_formats = ["{{municipality_code}}####"]
+
+    def provinces_code(self) -> str:
+        """
+        :example: "BA"
+        """
+        return self.random_element(self.provinces.keys())
+
+    def province(self) -> str:
+        """
+        :example: "Buenos Aires"
+        """
+        return self.random_element(list(self.provinces.values()))
+
+    administrative_unit = province
+
+    def municipality_code(self) -> str:
+        """
+        :example: "1900"
+        """
+        return self.random_element(self.municipalities)[0]  # type: ignore
+
+    def municipality(self) -> str:
+        """
+        :example: "La Plata"
+        """
+        return self.random_element(self.municipalities)[1]  # type: ignore
+
+    city = municipality
+
+    def street_prefix(self) -> str:
+        """
+        :example: "Calle"
+        """
+        return self.random_element(self.street_prefixes)
+
+    def street_procer(self) -> str:
+        """
+        :example: "Belgrano"
+        """
+        return self.random_element(self.street_proceres)
+
+    def street_municipality(self) -> str:
+        """
+        :example: "La Plata"
+        """
+        return self.random_element(self.municipalities)[1]
+
+    def street_province(self) -> str:
+        """
+        :example: "San Juan"
+        """
+        return self.random_element(list(self.provinces.values()))
+
+    def street_suffix(self) -> str:
+        """
+        :example: "Sur"
+        """
+        return self.generator.parse(self.random_element(self.street_suffixes))
+
+    def street_name(self) -> str:
+        """
+        :example: "Calle 1"
+        """
+        pattern: str = self.random_element(self.street_name_formats)
+        return self.numerify(self.generator.parse(pattern))
+
+    def building_number(self) -> str:
+        """
+        :example: "23"
+        """
+        return self.numerify(self.generator.parse(self.random_element(self.building_number_formats)))
+
+    def secondary_address(self) -> str:
+        """
+        :example: "Departamento 123"
+        """
+        return self.numerify(self.random_element(self.secondary_address_formats))
+
+    def street_address(self) -> str:
+        """
+        :example: "Calle 1 N° 23"
+        """
+        return self.street_name() + " N° " + self.building_number()
+
+    def postcode(self) -> str:
+        """
+        :example: "1900"
+        """
+        return self.numerify(self.generator.parse(self.random_element(self.postcode_formats)))
+
+    def address(self) -> str:
+        """
+        :example: "Calle 1 N° 23, La Plata 1900, Buenos Aires"
+        """
+        municipality: Tuple[str, str, str] = self.random_element(self.municipalities)
+        municipality_code = municipality[0]
+        municipality_prov = municipality[2]
+
+        secondary_address: str = self.random_element(
+            [
+                " " + self.secondary_address(),
+                "",
+            ]
+        )
+        postcode = "\n" + municipality[1] + " " + municipality_code
+        province_name = ", " + self.provinces[municipality_prov]
+
+        return self.street_address() + secondary_address + postcode + province_name

.venv/lib/python3.12/site-packages/faker/providers/address/es_CL/__init__.py

@@ -0,0 +1,648 @@
+from collections import OrderedDict
+from typing import Dict, Tuple
+
+from ... import ElementsType
+from ..es import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    # Source for regions, provinces and communes
+    # https://www.subdere.gov.cl/documentacion/c%C3%B3digos-%C3%BAnicos-
+    # territoriales-actualizados-al-06-de-septiembre-2018
+    regions: Dict[str, str] = {
+        "TA": "Región de Tarapacá",
+        "AN": "Región de Antofagasta",
+        "AT": "Región de Atacama",
+        "CO": "Región de Coquimbo",
+        "VA": "Región de Valparaíso",
+        "LI": "Región del Libertador General Bernardo O'Higgins",
+        "ML": "Región del Maule",
+        "BI": "Región del Biobío",
+        "AR": "Región de La Araucanía",
+        "LL": "Región de Los Lagos",
+        "AI": "Región de Aysén del General Carlos Ibáñez del Campo",
+        "MA": "Región de Magallanes y de la Antártica Chilena",
+        "RM": "Región Metropolitana",
+        "LR": "Región de Los Ríos",
+        "AP": "Región de Arica y Parinacota",
+        "NB": "Región de Ñuble",
+    }
+
+    provinces: Dict[str, str] = {
+        "011": "Iquique",
+        "014": "Tamarugal",
+        "021": "Antofagasta",
+        "022": "El Loa",
+        "023": "Tocopilla",
+        "031": "Copiapó",
+        "032": "Chañaral",
+        "033": "Huasco",
+        "041": "Elqui",
+        "042": "Choapa",
+        "043": "Limarí",
+        "051": "Valparaíso",
+        "052": "Isla de Pascua",
+        "053": "Los Andes",
+        "054": "Petorca",
+        "055": "Quillota",
+        "056": "San Antonio",
+        "057": "San Felipe de Aconcagua",
+        "058": "Marga Marga",
+        "061": "Cachapoal",
+        "062": "Cardenal Caro",
+        "063": "Colchagua",
+        "071": "Talca",
+        "072": "Cauquenes",
+        "073": "Curicó",
+        "074": "Linares",
+        "081": "Concepción",
+        "082": "Arauco",
+        "083": "Biobío",
+        "091": "Cautín",
+        "092": "Malleco",
+        "101": "Llanquihue",
+        "102": "Chiloé",
+        "103": "Osorno",
+        "104": "Palena",
+        "111": "Coyhaique",
+        "112": "Aysén",
+        "113": "Capitán Prat",
+        "114": "General Carrera",
+        "121": "Magallanes",
+        "122": "Antártica Chilena",
+        "123": "Tierra del Fuego",
+        "124": "Última Esperanza",
+        "131": "Santiago",
+        "132": "Cordillera",
+        "133": "Chacabuco",
+        "134": "Maipo",
+        "135": "Melipilla",
+        "136": "Talagante",
+        "141": "Valdivia",
+        "142": "Ranco",
+        "151": "Arica",
+        "152": "Parinacota",
+        "161": "Diguillín",
+        "162": "Itata",
+        "163": "Punilla",
+    }
+
+    communes: Dict[str, str] = {
+        "15101": "Arica",
+        "15102": "Camarones",
+        "15201": "Putre",
+        "15202": "General Lagos",
+        "01101": "Iquique",
+        "01402": "Camiña",
+        "01403": "Colchane",
+        "01404": "Huara",
+        "01405": "Pica",
+        "01401": "Pozo Almonte",
+        "01107": "Alto Hospicio",
+        "02101": "Antofagasta",
+        "02102": "Mejillones",
+        "02103": "Sierra Gorda",
+        "02104": "Taltal",
+        "02201": "Calama",
+        "02202": "Ollagüe",
+        "02203": "San Pedro de Atacama",
+        "02301": "Tocopilla",
+        "02302": "María Elena",
+        "03101": "Copiapó",
+        "03102": "Caldera",
+        "03103": "Tierra Amarilla",
+        "03201": "Chañaral",
+        "03202": "Diego de Almagro",
+        "03301": "Vallenar",
+        "03302": "Alto del Carmen",
+        "03303": "Freirina",
+        "03304": "Huasco",
+        "04101": "La Serena",
+        "04102": "Coquimbo",
+        "04103": "Andacollo",
+        "04104": "La Higuera",
+        "04105": "Paiguano",
+        "04106": "Vicuña",
+        "04201": "Illapel",
+        "04202": "Canela",
+        "04203": "Los Vilos",
+        "04204": "Salamanca",
+        "04301": "Ovalle",
+        "04302": "Combarbalá",
+        "04303": "Monte Patria",
+        "04304": "Punitaqui",
+        "04305": "Río Hurtado",
+        "05101": "Valparaíso",
+        "05102": "Casablanca",
+        "05103": "Concón",
+        "05104": "Juan Fernández",
+        "05105": "Puchuncaví",
+        "05801": "Quilpué",
+        "05107": "Quintero",
+        "05804": "Villa Alemana",
+        "05109": "Viña del Mar",
+        "05201": "Isla  de Pascua",
+        "05301": "Los Andes",
+        "05302": "Calle Larga",
+        "05303": "Rinconada",
+        "05304": "San Esteban",
+        "05401": "La Ligua",
+        "05402": "Cabildo",
+        "05403": "Papudo",
+        "05404": "Petorca",
+        "05405": "Zapallar",
+        "05501": "Quillota",
+        "05502": "Calera",
+        "05503": "Hijuelas",
+        "05504": "La Cruz",
+        "05802": "Limache",
+        "05506": "Nogales",
+        "05803": "Olmué",
+        "05601": "San Antonio",
+        "05602": "Algarrobo",
+        "05603": "Cartagena",
+        "05604": "El Quisco",
+        "05605": "El Tabo",
+        "05606": "Santo Domingo",
+        "05701": "San Felipe",
+        "05702": "Catemu",
+        "05703": "Llaillay",
+        "05704": "Panquehue",
+        "05705": "Putaendo",
+        "05706": "Santa María",
+        "06101": "Rancagua",
+        "06102": "Codegua",
+        "06103": "Coinco",
+        "06104": "Coltauco",
+        "06105": "Doñihue",
+        "06106": "Graneros",
+        "06107": "Las Cabras",
+        "06108": "Machalí",
+        "06109": "Malloa",
+        "06110": "Mostazal",
+        "06111": "Olivar",
+        "06112": "Peumo",
+        "06113": "Pichidegua",
+        "06114": "Quinta de Tilcoco",
+        "06115": "Rengo",
+        "06116": "Requínoa",
+        "06117": "San Vicente",
+        "06201": "Pichilemu",
+        "06202": "La Estrella",
+        "06203": "Litueche",
+        "06204": "Marchihue",
+        "06205": "Navidad",
+        "06206": "Paredones",
+        "06301": "San Fernando",
+        "06302": "Chépica",
+        "06303": "Chimbarongo",
+        "06304": "Lolol",
+        "06305": "Nancagua",
+        "06306": "Palmilla",
+        "06307": "Peralillo",
+        "06308": "Placilla",
+        "06309": "Pumanque",
+        "06310": "Santa Cruz",
+        "07101": "Talca",
+        "07102": "Constitución",
+        "07103": "Curepto",
+        "07104": "Empedrado",
+        "07105": "Maule",
+        "07106": "Pelarco",
+        "07107": "Pencahue",
+        "07108": "Río Claro",
+        "07109": "San Clemente",
+        "07110": "San Rafael",
+        "07201": "Cauquenes",
+        "07202": "Chanco",
+        "07203": "Pelluhue",
+        "07301": "Curicó",
+        "07302": "Hualañé",
+        "07303": "Licantén",
+        "07304": "Molina",
+        "07305": "Rauco",
+        "07306": "Romeral",
+        "07307": "Sagrada Familia",
+        "07308": "Teno",
+        "07309": "Vichuquén",
+        "07401": "Linares",
+        "07402": "Colbún",
+        "07403": "Longaví",
+        "07404": "Parral",
+        "07405": "Retiro",
+        "07406": "San Javier",
+        "07407": "Villa Alegre",
+        "07408": "Yerbas Buenas",
+        "08101": "Concepción",
+        "08102": "Coronel",
+        "08103": "Chiguayante",
+        "08104": "Florida",
+        "08105": "Hualqui",
+        "08106": "Lota",
+        "08107": "Penco",
+        "08108": "San Pedro de la Paz",
+        "08109": "Santa Juana",
+        "08110": "Talcahuano",
+        "08111": "Tomé",
+        "08112": "Hualpén",
+        "08201": "Lebu",
+        "08202": "Arauco",
+        "08203": "Cañete",
+        "08204": "Contulmo",
+        "08205": "Curanilahue",
+        "08206": "Los Álamos",
+        "08207": "Tirúa",
+        "08301": "Los Ángeles",
+        "08302": "Antuco",
+        "08303": "Cabrero",
+        "08304": "Laja",
+        "08305": "Mulchén",
+        "08306": "Nacimiento",
+        "08307": "Negrete",
+        "08308": "Quilaco",
+        "08309": "Quilleco",
+        "08310": "San Rosendo",
+        "08311": "Santa Bárbara",
+        "08312": "Tucapel",
+        "08313": "Yumbel",
+        "08314": "Alto Biobío",
+        "16101": "Chillán",
+        "16102": "Bulnes",
+        "16202": "Cobquecura",
+        "16203": "Coelemu",
+        "16302": "Coihueco",
+        "16103": "Chillán Viejo",
+        "16104": "El Carmen",
+        "16204": "Ninhue",
+        "16303": "Ñiquén",
+        "16105": "Pemuco",
+        "16106": "Pinto",
+        "16205": "Portezuelo",
+        "16107": "Quillón",
+        "16201": "Quirihue",
+        "16206": "Ránquil",
+        "16301": "San Carlos",
+        "16304": "San Fabián",
+        "16108": "San Ignacio",
+        "16305": "San Nicolás",
+        "16207": "Treguaco",
+        "16109": "Yungay",
+        "09101": "Temuco",
+        "09102": "Carahue",
+        "09103": "Cunco",
+        "09104": "Curarrehue",
+        "09105": "Freire",
+        "09106": "Galvarino",
+        "09107": "Gorbea",
+        "09108": "Lautaro",
+        "09109": "Loncoche",
+        "09110": "Melipeuco",
+        "09111": "Nueva Imperial",
+        "09112": "Padre Las Casas",
+        "09113": "Perquenco",
+        "09114": "Pitrufquén",
+        "09115": "Pucón",
+        "09116": "Saavedra",
+        "09117": "Teodoro Schmidt",
+        "09118": "Toltén",
+        "09119": "Vilcún",
+        "09120": "Villarrica",
+        "09121": "Cholchol",
+        "09201": "Angol",
+        "09202": "Collipulli",
+        "09203": "Curacautín",
+        "09204": "Ercilla",
+        "09205": "Lonquimay",
+        "09206": "Los Sauces",
+        "09207": "Lumaco",
+        "09208": "Purén",
+        "09209": "Renaico",
+        "09210": "Traiguén",
+        "09211": "Victoria",
+        "14101": "Valdivia",
+        "14102": "Corral",
+        "14202": "Futrono",
+        "14201": "La Unión",
+        "14203": "Lago Ranco",
+        "14103": "Lanco",
+        "14104": "Los Lagos",
+        "14105": "Máfil",
+        "14106": "Mariquina",
+        "14107": "Paillaco",
+        "14108": "Panguipulli",
+        "14204": "Río Bueno",
+        "10101": "Puerto Montt",
+        "10102": "Calbuco",
+        "10103": "Cochamó",
+        "10104": "Fresia",
+        "10105": "Frutillar",
+        "10106": "Los Muermos",
+        "10107": "Llanquihue",
+        "10108": "Maullín",
+        "10109": "Puerto Varas",
+        "10201": "Castro",
+        "10202": "Ancud",
+        "10203": "Chonchi",
+        "10204": "Curaco de Vélez",
+        "10205": "Dalcahue",
+        "10206": "Puqueldón",
+        "10207": "Queilén",
+        "10208": "Quellón",
+        "10209": "Quemchi",
+        "10210": "Quinchao",
+        "10301": "Osorno",
+        "10302": "Puerto Octay",
+        "10303": "Purranque",
+        "10304": "Puyehue",
+        "10305": "Río Negro",
+        "10306": "San Juan de la Costa",
+        "10307": "San Pablo",
+        "10401": "Chaitén",
+        "10402": "Futaleufú",
+        "10403": "Hualaihué",
+        "10404": "Palena",
+        "11101": "Coihaique",
+        "11102": "Lago Verde",
+        "11201": "Aisén",
+        "11202": "Cisnes",
+        "11203": "Guaitecas",
+        "11301": "Cochrane",
+        "11302": "O'Higgins",
+        "11303": "Tortel",
+        "11401": "Chile Chico",
+        "11402": "Río Ibáñez",
+        "12101": "Punta Arenas",
+        "12102": "Laguna Blanca",
+        "12103": "Río Verde",
+        "12104": "San Gregorio",
+        "12201": "Cabo de Hornos",
+        "12202": "Antártica",
+        "12301": "Porvenir",
+        "12302": "Primavera",
+        "12303": "Timaukel",
+        "12401": "Natales",
+        "12402": "Torres del Paine",
+        "13101": "Santiago",
+        "13102": "Cerrillos",
+        "13103": "Cerro Navia",
+        "13104": "Conchalí",
+        "13105": "El Bosque",
+        "13106": "Estación Central",
+        "13107": "Huechuraba",
+        "13108": "Independencia",
+        "13109": "La Cisterna",
+        "13110": "La Florida",
+        "13111": "La Granja",
+        "13112": "La Pintana",
+        "13113": "La Reina",
+        "13114": "Las Condes",
+        "13115": "Lo Barnechea",
+        "13116": "Lo Espejo",
+        "13117": "Lo Prado",
+        "13118": "Macul",
+        "13119": "Maipú",
+        "13120": "Ñuñoa",
+        "13121": "Pedro Aguirre Cerda",
+        "13122": "Peñalolén",
+        "13123": "Providencia",
+        "13124": "Pudahuel",
+        "13125": "Quilicura",
+        "13126": "Quinta Normal",
+        "13127": "Recoleta",
+        "13128": "Renca",
+        "13129": "San Joaquín",
+        "13130": "San Miguel",
+        "13131": "San Ramón",
+        "13132": "Vitacura",
+        "13201": "Puente Alto",
+        "13202": "Pirque",
+        "13203": "San José de Maipo",
+        "13301": "Colina",
+        "13302": "Lampa",
+        "13303": "Tiltil",
+        "13401": "San Bernardo",
+        "13402": "Buin",
+        "13403": "Calera de Tango",
+        "13404": "Paine",
+        "13501": "Melipilla",
+        "13502": "Alhué",
+        "13503": "Curacaví",
+        "13504": "María Pinto",
+        "13505": "San Pedro",
+        "13601": "Talagante",
+        "13602": "El Monte",
+        "13603": "Isla de Maipo",
+        "13604": "Padre Hurtado",
+        "13605": "Peñaflor",
+    }
+
+    street_prefixes = OrderedDict(
+        [
+            ("Calle", 0.6),
+            ("Avenida", 0.1),
+            ("Avda.", 0.1),
+            ("Av.", 0.1),
+            ("Pasaje", 0.04),
+            ("Psje.", 0.04),
+            ("Camino", 0.02),
+        ]
+    )
+
+    street_suffixes = (
+        "Norte",
+        "Sur",
+    )
+
+    city_formats = ("{{city}}",)
+
+    street_name_formats = (
+        "{{street_prefix}} {{common_street_name}}",
+        "{{street_prefix}} {{historic_people_street_name}}",
+        "{{street_prefix}} {{first_name_male}} {{last_name}}",
+        "{{street_prefix}} {{first_name_female}} {{last_name}}",
+        "{{street_prefix}} {{plant_street_name}}",
+        "{{common_street_name}}",
+        "{{historic_people_street_name}}",
+        "{{plant_street_name}}",
+        "{{first_name_male}} {{last_name}}",
+        "{{first_name_female}} {{last_name}}",
+    )
+
+    building_number_formats = OrderedDict(
+        [
+            ("%###", 0.35),
+            ("%##", 0.35),
+            ("%#", 0.25),
+            ("%", 0.05),
+        ]
+    )
+
+    street_address_formats = (
+        "{{street_name}} {{building_number}}",
+        "{{street_name}} {{building_number}} {{secondary_address}}",
+    )
+
+    address_formats = OrderedDict(
+        [
+            ("{{street_address}}\n{{commune_and_region}}, {{postcode}}", 0.4),
+            ("{{street_address}}\n{{commune_and_region}}", 0.4),
+            ("{{highway_name}}, km {{random_int:big_kilometer}}", 0.1),
+            ("{{road_name}}, km {{random_int:kilometer}}, {{region}}", 0.1),
+        ]
+    )
+
+    secondary_address_formats = ("Dpto. @@##", "Piso @#", "Of. %##@")
+
+    common_street_names = OrderedDict(
+        [
+            ("Arturo Prat", 0.118812),
+            ("Esmeralda", 0.107261),
+            ("Manuel Rodríguez", 0.105611),
+            ("Gabriela Mistral", 0.104785),
+            ("Los Aromos", 0.104785),
+            ("Las Rosas", 0.098185),
+            ("Caupolicán", 0.094884),
+            ("Lautaro", 0.094059),
+            ("Los Alerces", 0.086634),
+            ("Los Copihues", 0.084983),
+        ]
+    )
+
+    # Some chilean historic people. Full names come first, then its variants
+    historic_people_street_names = (
+        ("Alonso de Ercilla",),
+        ("Alonso de Ribera",),
+        ("Álvaro Casanova", "Casanova"),
+        ("Aníbal Pinto Garmendia", "Aníbal Pinto"),
+        ("Antonio Varas",),
+        ("Arturo Alessandri Palma", "Arturo Alessandri"),
+        ("Benjamín Vicuña Mackenna", "Vicuña Mackenna", "Mackenna"),
+        ("Bernardo O'Higgins", "O'Higgins"),
+        ("Camilo Henríquez",),
+        ("Caupolicán",),
+        ("Colo Colo",),
+        ("Diego Barros Arana", "Barros Arana"),
+        ("Diego Portales", "Portales"),
+        ("Domingo Santa María", "Santa María"),
+        ("Eliodoro Yáñez",),
+        ("Enrique Mac Iver", "Mac Iver"),
+        ("Eusebio Lillo",),
+        ("Francisco Bilbao", "Bilbao"),
+        ("José de San Martín", "San Martín"),
+        ("José Manuel Balmaceda", "Balmaceda"),
+        ("José Miguel Carrera",),
+        ("José Victorino Lastarria", "Lastarria"),
+        ("Juan Mackenna",),
+        ("Lord Thomas Cochrane", "Lord Cochrane", "Cochrane"),
+        ("Los Carrera",),
+        ("Manuel Antonio Matta", "Matta"),
+        ("Manuel Bulnes", "Bulnes"),
+        ("Manuel José Irarrázaval", "Irarrázabal"),
+        ("Manuel Montt",),
+        ("Manuel Rodríguez",),
+        ("Manuel Baquedano", "Baquedano"),
+        ("Michimalonco",),
+        ("Padre Alberto Hurtado", "Alberto Hurtado"),
+        ("Patricio Lynch", "Lynch"),
+        ("Paula Jaraquemada",),
+        ("Pedro Aguirre Cerda",),
+        ("Pedro de Valdivia",),
+        ("Pedro Montt",),
+        ("Ramón Barros Luco", "Barros Luco"),
+        ("Ramón Carnicer",),
+        ("Ramón Freire", "Freire"),
+        ("Ramón Picarte", "Picarte"),
+        ("Salvador Allende Gossens", "Salvador Allende"),
+        ("Santa Rosa",),
+    )
+
+    # Some streets are named by plants
+    plant_street_names: ElementsType[str] = (
+        "Los Cactus",
+        "Los Laureles",
+        "Los Piñones",
+        "Los Helechos",
+        "Los Higos",
+        "Los Abedules",
+        "Los Encinos",
+        "Los Palmitos",
+        "Los Naranjos",
+        "Los Robles",
+        "Los Pinos",
+        "Los Coihues",
+        "Los Calafates",
+        "Los Digitales",
+        "Los Lirios",
+        "Los Tilos",
+        "Los Girasoles",
+        "Las Azucenas",
+        "Las Lilas",
+        "Las Hortensias",
+        "Las Margaritas",
+        "Las Maravillas",
+        "Las Manzanillas",
+        "Las Mandarinas",
+        "Las Araucarias",
+        "Las Mosquetas",
+        "Las Malvas",
+        "Las Mosquetas",
+    )
+
+    road_names = ("Ruta T-%#", "Ruta U-%##", "Ruta %##-CH")
+    highway_names = ("Ruta 5 Norte", "Ruta 5 Sur")
+
+    def commune(self) -> str:
+        return self.random_element(self.communes.values())
+
+    def province(self) -> str:
+        return self.random_element(self.provinces.values())
+
+    def region(self) -> str:
+        return self.random_element(self.regions.values())
+
+    def commune_code(self) -> str:
+        return self.random_element(self.communes.keys())
+
+    def province_code(self) -> str:
+        return self.random_element(self.provinces.keys())
+
+    def region_code(self) -> str:
+        return self.random_element(self.regions.keys())
+
+    def common_street_name(self) -> str:
+        return self.random_element(self.common_street_names)
+
+    def plant_street_name(self) -> str:
+        return self.random_element(self.plant_street_names)
+
+    def historic_people_street_name(self) -> str:
+        person_names: Tuple[str, ...] = self.random_element(self.historic_people_street_names)
+        return self.random_element(person_names)
+
+    def street_prefix(self) -> str:
+        return self.random_element(self.street_prefixes)
+
+    def secondary_address(self) -> str:
+        return self.numerify(self.random_element(self.secondary_address_formats))
+
+    def commune_and_region(self) -> str:
+        commune_code = self.commune_code()
+        commune_name = self.communes[commune_code]
+        region_index = int(commune_code[0:2]) - 1
+        region_name = tuple(self.regions.values())[region_index]
+
+        return f"{commune_name:s}, {region_name:s}"
+
+    def road_name(self) -> str:
+        self.generator.set_arguments("kilometer", {"min": 1, "max": 35})
+        return self.numerify(self.generator.parse(self.random_element(self.road_names)))
+
+    def highway_name(self) -> str:
+        self.generator.set_arguments("big_kilometer", {"min": 1, "max": 1000})
+        return self.numerify(self.generator.parse(self.random_element(self.highway_names)))
+
+    def postcode(self) -> str:
+        return self.numerify("######0")
+
+    administrative_unit = region
+    city = commune

.venv/lib/python3.12/site-packages/faker/providers/address/es_ES/__init__.py

@@ -0,0 +1,140 @@
+from ..es import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    building_number_formats = ("%", "%#", "%#", "%#", "%##")
+    street_prefixes = (
+        "Plaza",
+        "Calle",
+        "Avenida",
+        "Via",
+        "Vial",
+        "Rambla",
+        "Glorieta",
+        "Urbanización",
+        "Callejón",
+        "Cañada",
+        "Alameda",
+        "Acceso",
+        "C.",
+        "Ronda",
+        "Pasaje",
+        "Cuesta",
+        "Pasadizo",
+        "Paseo",
+        "Camino",
+    )
+    states = (
+        "Álava",
+        "Albacete",
+        "Alicante",
+        "Almería",
+        "Asturias",
+        "Ávila",
+        "Badajoz",
+        "Baleares",
+        "Barcelona",
+        "Burgos",
+        "Cáceres",
+        "Cádiz",
+        "Cantabria",
+        "Castellón",
+        "Ceuta",
+        "Ciudad",
+        "Córdoba",
+        "Cuenca",
+        "Girona",
+        "Granada",
+        "Guadalajara",
+        "Guipúzcoa",
+        "Huelva",
+        "Huesca",
+        "Jaén",
+        "La Coruña",
+        "La Rioja",
+        "Las Palmas",
+        "León",
+        "Lleida",
+        "Lugo",
+        "Madrid",
+        "Málaga",
+        "Melilla",
+        "Murcia",
+        "Navarra",
+        "Ourense",
+        "Palencia",
+        "Pontevedra",
+        "Salamanca",
+        "Santa Cruz de Tenerife",
+        "Segovia",
+        "Sevilla",
+        "Soria",
+        "Tarragona",
+        "Teruel",
+        "Toledo",
+        "Valencia",
+        "Valladolid",
+        "Vizcaya",
+        "Zamora",
+        "Zaragoza",
+    )
+
+    # Source:
+    # https://administracionelectronica.gob.es/ctt/resources/Soluciones
+    # /238/Descargas/Catalogo-de-Comunidades-Autonomas.xlsx
+    regions = (
+        "Andalucía",
+        "Aragón",
+        "Principado de Asturias",
+        "Illes Balears",
+        "Canarias",
+        "Cantabria",
+        "Castilla y León",
+        "Castilla-La Mancha",
+        "Cataluña",
+        "Comunitat Valenciana",
+        "Extremadura",
+        "Galicia",
+        "Comunidad de Madrid",
+        "Región de Murcia",
+        "Comunidad Foral de Navarra",
+        "País Vasco",
+        "La Rioja",
+        "Ciudad Autónoma de Ceuta",
+        "Ciudad Autónoma de Melilla",
+    )
+
+    city_formats = ("{{state_name}}",)
+
+    street_name_formats = (
+        "{{street_prefix}} {{first_name}} {{last_name}}",
+        "{{street_prefix}} de {{first_name}} {{last_name}}",
+    )
+    street_address_formats = (
+        "{{street_name}} {{building_number}}",
+        "{{street_name}} {{building_number}} {{secondary_address}} ",
+    )
+    address_formats = ("{{street_address}}\n{{city}}, {{postcode}}",)
+    secondary_address_formats = ("Apt. ##", "Piso #", "Puerta #")
+
+    def state_name(self) -> str:
+        return self.random_element(self.states)
+
+    def street_prefix(self) -> str:
+        return self.random_element(self.street_prefixes)
+
+    def secondary_address(self) -> str:
+        return self.numerify(self.random_element(self.secondary_address_formats))
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.states)
+
+    state = administrative_unit
+
+    def region(self) -> str:
+        return self.random_element(self.regions)
+
+    def postcode(self) -> str:
+        return str(self.generator.random.randint(1000, 52100)).zfill(5)
+
+    autonomous_community = region

.venv/lib/python3.12/site-packages/faker/providers/address/es_MX/__init__.py

@@ -0,0 +1,163 @@
+from collections import OrderedDict
+
+from ..es import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_prefixes = ("Sur", "Norte")
+    city_adjectives = ("Nueva", "Vieja")
+    city_suffixes = ("de la Montaña", "los bajos", "los altos")
+    street_prefixes = (
+        "Ampliación",
+        "Andador",
+        "Avenida",
+        "Boulevard",
+        "Calle",
+        "Callejón",
+        "Calzada",
+        "Cerrada",
+        "Circuito",
+        "Circunvalación",
+        "Continuación",
+        "Corredor",
+        "Diagonal",
+        "Eje vial",
+        "Pasaje",
+        "Peatonal",
+        "Periférico",
+        "Privada",
+        "Prolongación",
+        "Retorno",
+        "Viaducto",
+    )
+    building_number_formats = ("#####", "####", "###")
+    postcode_formats = ("#####", "#####-####")
+
+    # States and abbrs from Mexico from INEGI
+    # http://www.inegi.org.mx/geo/contenidos/geoestadistica/CatalogoClaves.aspx
+    states = (
+        ("AGS", "Aguascalientes"),
+        ("BC", "Baja California"),
+        ("BCS", "Baja California Sur"),
+        ("CAMP", "Campeche"),
+        ("COAH", "Coahuila de Zaragoza"),
+        ("COL", "Colima"),
+        ("CHIS", "Chiapas"),
+        ("CHIH", "Chihuahua"),
+        ("DF", "Distrito Federal"),
+        ("DGO", "Durango"),
+        ("GTO", "Guanajuato"),
+        ("GRO", "Guerrero"),
+        ("HGO", "Hidalgo"),
+        ("JAL", "Jalisco"),
+        ("MEX", "México"),
+        ("MICH", "Michoacán de Ocampo"),
+        ("MOR", "Morelos"),
+        ("NAY", "Nayarit"),
+        ("NL", "Nuevo León"),
+        ("OAX", "Oaxaca"),
+        ("PUE", "Puebla"),
+        ("QRO", "Querétaro"),
+        ("Q. ROO", "Quintana Roo"),
+        ("SLP", "San Luis Potosí"),
+        ("SIN", "Sinaloa"),
+        ("SON", "Sonora"),
+        ("TAB", "Tabasco"),
+        ("TAMPS", "Tamaulipas"),
+        ("TLAX", "Tlaxcala"),
+        ("VER", "Veracruz de Ignacio de la Llave"),
+        ("YUC", "Yucatán"),
+        ("ZAC", "Zacatecas"),
+    )
+
+    zip_codes = OrderedDict(
+        (
+            # The ZipCodes has a begin & final range
+            # Source: Norma Técnica de Domicilios INEGI
+            ("AGS", (20000, 20999)),
+            ("BC", (21000, 22999)),
+            ("BCS", (23000, 23999)),
+            ("CAMP", (24000, 24999)),
+            ("COAH", (25000, 27999)),
+            ("COL", (28000, 28999)),
+            ("CHIS", (29000, 30999)),
+            ("CHIH", (31000, 33999)),
+            ("DF", (1000, 19999)),
+            ("DGO", (36000, 35999)),
+            ("GTO", (36000, 38999)),
+            ("GRO", (39000, 41999)),
+            ("HGO", (42000, 43999)),
+            ("JAL", (44000, 49999)),
+            ("MEX", (50000, 57999)),
+            ("MICH", (58000, 61999)),
+            ("MOR", (62000, 62999)),
+            ("NAY", (63000, 63999)),
+            ("NL", (64000, 67999)),
+            ("OAX", (68000, 71999)),
+            ("PUE", (72000, 75999)),
+            ("QRO", (76000, 76999)),
+            ("Q. ROO", (77000, 75999)),
+            ("SLP", (78000, 79999)),
+            ("SIN", (80000, 82999)),
+            ("SON", (83000, 85999)),
+            ("TAB", (86000, 86999)),
+            ("TAMPS", (87000, 89999)),
+            ("TLAX", (90000, 90999)),
+            ("VER", (91000, 97999)),
+            ("YUC", (97000, 97999)),
+            ("ZAC", (98000, 99999)),
+        )
+    )
+
+    city_formats = (
+        "{{city_adjective}} {{country}}",
+        "San {{first_name}} {{city_suffix}}",
+    )
+    street_name_formats = (
+        "{{street_prefix}} {{last_name}}",
+        "{{street_prefix}} {{country}}",
+        "{{street_prefix}} {{state}}",
+        "{{street_prefix}} {{city_prefix}} {{last_name}}",
+    )
+    street_address_formats = ("{{street_name}} {{secondary_address}}",)
+    address_formats = ("{{street_address}}\n{{city}}, {{state_abbr}} {{postcode}}",)
+    secondary_address_formats = (
+        "### ###",
+        "### Interior ###",
+        "### Edif. ### , Depto. ###",
+    )
+
+    def city_prefix(self) -> str:
+        return self.random_element(self.city_prefixes)
+
+    def city_suffix(self) -> str:
+        return self.random_element(self.city_suffixes)
+
+    def city_adjective(self) -> str:
+        return self.random_element(self.city_adjectives)
+
+    def street_prefix(self) -> str:
+        """
+        :example 'Avenida'
+        """
+        return self.random_element(self.street_prefixes)
+
+    def secondary_address(self) -> str:
+        """
+        :example '020 Interior 999'
+        """
+        return self.numerify(self.random_element(self.secondary_address_formats))
+
+    def administrative_unit(self) -> str:
+        """
+        example: u'Guerrero'
+        """
+        return self.random_element(self.states)[1]  # type: ignore
+
+    state = administrative_unit
+
+    def state_abbr(self) -> str:
+        """
+        example: u'GRO'
+        """
+        return self.random_element(self.states)[0]  # type: ignore

.venv/lib/python3.12/site-packages/faker/providers/address/fa_IR/__init__.py

@@ -0,0 +1,296 @@
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_prefixes = (
+        "شمال",
+        "غرب",
+        "شرق",
+        "جنوب",
+        "بندر",
+        "شهر",
+        "روستای",
+        "دهستان",
+        "شهرستان",
+        "باغات",
+        "استان",
+    )
+    building_number_formats = ("#####", "####", "###")
+    street_suffixes = (
+        "کوچه",
+        "خیابان",
+        "پل",
+        "دره",
+        "میدان",
+        "چهار راه",
+        "بن بست",
+        "بلوار",
+        "جنب",
+        "تقاطع",
+        "آزاد راه",
+        "بزرگ راه",
+        "جزیره",
+        "کوه",
+        "جاده",
+        "تونل",
+    )
+    postcode_formats = ("###", "####", "#####", "######", "##########")
+    states = (
+        "آذربایجان شرقی",
+        "آذربایجان غربی",
+        "اردبیل",
+        "خراسان",
+        "کردستان",
+        "گیلان",
+        "اصفهان",
+        "البرز",
+        "ایلام",
+        "بوشهر",
+        "تهران",
+        "چهارمحال و بختیاری",
+        "خراسان جنوبی",
+        "خراسان رضوی",
+        "خراسان شمالی",
+        "خوزستان",
+        "زنجان",
+        "سمنان",
+        "سیستان و بلوچستان",
+        "فارس",
+        "قزوین",
+        "قم",
+        "کرمان",
+        "کرمانشاه",
+        "کهگیلویه و بویراحمد",
+        "گلستان",
+        "لرستان",
+        "مازندران",
+        "مرکزی",
+        "هرمزگان",
+        "همدان",
+        "یزد",
+    )
+    countries = (
+        "جمهوری آذربایجان",
+        "آرژانتین",
+        "آفریقای جنوبی",
+        "جمهوری آفریقای مرکزی",
+        "آلبانی",
+        "آلمان",
+        "آنتیگوا و باربودا",
+        "آندورا",
+        "آنگولا",
+        "اتریش",
+        "اتیوپی",
+        "اردن",
+        "ارمنستان",
+        "اروگوئه",
+        "اریتره",
+        "ازبکستان",
+        "اسپانیا",
+        "استرالیا",
+        "استونی",
+        "اسرائیل",
+        "اسلواکی",
+        "اسلوونی",
+        "افغانستان",
+        "اکوادور",
+        "الجزایر",
+        "السالوادور",
+        "امارات متحده عربی",
+        "اندونزی",
+        "اوکراین",
+        "اوگاندا",
+        "ایالات متحده آمریکا",
+        "ایتالیا",
+        "ایران",
+        "جمهوری ایرلند",
+        "ایسلند",
+        "باربادوس",
+        "باهاما",
+        "بحرین",
+        "برزیل",
+        "برونئی",
+        "بریتانیا",
+        "بلاروس",
+        "بلژیک",
+        "بلغارستان",
+        "بلیز",
+        "بنگلادش",
+        "بنین",
+        "پادشاهی بوتان",
+        "بوتسوانا",
+        "بورکینافاسو",
+        "بوروندی",
+        "بوسنی و هرزگوین",
+        "بولیوی",
+        "پاپوآ گینه نو",
+        "پاراگوئه",
+        "پاناما",
+        "پاکستان",
+        "پرتغال",
+        "پرو",
+        "پورتوریکو",
+        "تاجیکستان",
+        "تانزانیا",
+        "تایلند",
+        "جمهوری چین",
+        "ترکمنستان",
+        "ترکیه",
+        "ترینیداد و توباگو",
+        "توگو",
+        "تونس",
+        "تونگا",
+        "تووالو",
+        "تیمور شرقی",
+        "جامائیکا",
+        "جزایر سلیمان",
+        "جزایر مارشال",
+        "جمهوری چک",
+        "جمهوری دومینیکن",
+        "جیبوتی",
+        "چاد",
+        "چین",
+        "دانمارک",
+        "دومینیکا",
+        "جمهوری دومینیکن",
+        "رواندا",
+        "روسیه",
+        "رومانی",
+        "زامبیا",
+        "نیوزیلند",
+        "زیمباوه",
+        "جمهوری دموکراتیک کنگو (زئیر)",
+        "ژاپن",
+        "سائوتومه و پرینسیپ",
+        "ساحل عاج",
+        "ساموآی غربی",
+        "سن مارینو",
+        "سری‌لانکا",
+        "سنت کیتس و نویس",
+        "سنت لوسیا",
+        "سنت وینسنت و گرنادین‌ها",
+        "سنگاپور",
+        "سنگال",
+        "سوئد",
+        "سوئیس",
+        "سوازیلند",
+        "سودان",
+        "سودان جنوبی",
+        "سورینام",
+        "سوریه",
+        "سومالی",
+        "سیرالئون",
+        "سیشل",
+        "شیلی",
+        "صربستان",
+        "عراق",
+        "عربستان سعودی",
+        "عمان",
+        "غنا",
+        "فرانسه",
+        "فلسطین",
+        "فنلاند",
+        "فیجی",
+        "فیلیپین",
+        "قبرس",
+        "قرقیزستان",
+        "قزاقستان",
+        "قطر",
+        "کامبوج",
+        "کامرون",
+        "کانادا",
+        "کره جنوبی",
+        "کره شمالی",
+        "کرواسی",
+        "کاستاریکا",
+        "کلمبیا",
+        "جمهوری کنگو",
+        "جمهوری دموکراتیک کنگو",
+        "کنیا",
+        "کوبا",
+        "کوزوو",
+        "مجمع‌الجزایر قمر",
+        "کویت",
+        "کیپ ورد",
+        "کیریباتی",
+        "گابن",
+        "گامبیا",
+        "گرجستان",
+        "گرنادا",
+        "گرینلند(از مستعمرات دانمارک)",
+        "گواتمالا",
+        "گویان",
+        "گینه",
+        "گینه استوایی",
+        "گینه بیسائو",
+        "لائوس",
+        "لبنان",
+        "لتونی",
+        "لسوتو",
+        "لهستان",
+        "لوکزامبورگ",
+        "لیبریا",
+        "لیبی",
+        "لیتوانی",
+        "لیختن‌اشتاین",
+        "ماداگاسکار",
+        "مالاوی",
+        "مالت",
+        "مالدیو",
+        "مالزی",
+        "مالی",
+        "مجارستان",
+        "مراکش",
+        "مصر",
+        "مغولستان",
+        "مقدونیه شمالی",
+        "مکزیک",
+        "موریتانی",
+        "موریس",
+        "موزامبیک",
+        "مولداوی",
+        "موناکو",
+        "مونته‌نگرو",
+        "میانمار",
+        "ایالات فدرال میکرونزی",
+        "نائورو",
+        "نامیبیا",
+        "نپال",
+        "نروژ",
+        "نیجریه",
+        "نیکاراگوئه",
+        "نیوزیلند",
+        "واتیکان",
+        "وانواتو",
+        "ونزوئلا",
+        "ویتنام",
+        "هائیتی",
+        "هلند",
+        "هندوراس",
+        "هند",
+        "یمن",
+        "یونان",
+    )
+
+    city_formats = ("{{city_prefix}} {{first_name}}",)
+    street_name_formats = (
+        "{{first_name}} {{street_suffix}}",
+        "{{last_name}} {{street_suffix}}",
+    )
+    street_address_formats = (
+        "{{building_number}} {{street_name}}",
+        "{{building_number}} {{street_name}} {{secondary_address}}",
+    )
+    address_formats = ("{{street_address}}\n{{city}}, {{state}} {{postcode}}",)
+    secondary_address_formats = ("سوئیت ###", "واحد ###")
+
+    def city_prefix(self) -> str:
+        return self.random_element(self.city_prefixes)
+
+    def secondary_address(self) -> str:
+        return self.numerify(self.random_element(self.secondary_address_formats))
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.states)
+
+    state = administrative_unit

.venv/lib/python3.12/site-packages/faker/providers/address/fi_FI/__init__.py

@@ -0,0 +1,800 @@
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    building_number_formats = ("###", "##", "#")
+
+    postcode_formats = ("#####",)
+
+    city_formats = ("{{city_name}}",)
+
+    street_name_formats = ("{{street_prefix}}{{street_suffix}}",)
+
+    street_address_formats = ("{{street_name}} {{building_number}}",)
+
+    address_formats = ("{{street_address}}\n{{postcode}} {{city}}",)
+
+    # Data from:
+    # https://www.avoindata.fi/data/en/dataset/kunnat/resource/b1cb9870-191f-4616-9c53-5388b7ca6beb
+    cities = (
+        "Alajärvi",
+        "Alavieska",
+        "Alavus",
+        "Asikkala",
+        "Askola",
+        "Aura",
+        "Akaa",
+        "Brändö",
+        "Eckerö",
+        "Enonkoski",
+        "Enontekiö",
+        "Espoo",
+        "Eura",
+        "Eurajoki",
+        "Evijärvi",
+        "Finström",
+        "Forssa",
+        "Föglö",
+        "Geta",
+        "Haapajärvi",
+        "Haapavesi",
+        "Hailuoto",
+        "Halsua",
+        "Hamina",
+        "Hammarland",
+        "Hankasalmi",
+        "Hanko",
+        "Harjavalta",
+        "Hartola",
+        "Hattula",
+        "Hausjärvi",
+        "Heinävesi",
+        "Helsinki",
+        "Vantaa",
+        "Hirvensalmi",
+        "Hollola",
+        "Honkajoki",
+        "Huittinen",
+        "Humppila",
+        "Hyrynsalmi",
+        "Hyvinkää",
+        "Hämeenkyrö",
+        "Hämeenlinna",
+        "Heinola",
+        "Ii",
+        "Iisalmi",
+        "Iitti",
+        "Ikaalinen",
+        "Ilmajoki",
+        "Ilomantsi",
+        "Inari",
+        "Inkoo",
+        "Isojoki",
+        "Isokyrö",
+        "Imatra",
+        "Janakkala",
+        "Joensuu",
+        "Jokioinen",
+        "Jomala",
+        "Joroinen",
+        "Joutsa",
+        "Juuka",
+        "Juupajoki",
+        "Juva",
+        "Jyväskylä",
+        "Jämijärvi",
+        "Jämsä",
+        "Järvenpää",
+        "Kaarina",
+        "Kaavi",
+        "Kajaani",
+        "Kalajoki",
+        "Kangasala",
+        "Kangasniemi",
+        "Kankaanpää",
+        "Kannonkoski",
+        "Kannus",
+        "Karijoki",
+        "Karkkila",
+        "Karstula",
+        "Karvia",
+        "Kaskinen",
+        "Kauhajoki",
+        "Kauhava",
+        "Kauniainen",
+        "Kaustinen",
+        "Keitele",
+        "Kemi",
+        "Keminmaa",
+        "Kempele",
+        "Kerava",
+        "Keuruu",
+        "Kihniö",
+        "Kinnula",
+        "Kirkkonummi",
+        "Kitee",
+        "Kittilä",
+        "Kiuruvesi",
+        "Kivijärvi",
+        "Kokemäki",
+        "Kokkola",
+        "Kolari",
+        "Konnevesi",
+        "Kontiolahti",
+        "Korsnäs",
+        "Koski Tl",
+        "Kotka",
+        "Kouvola",
+        "Kristiinankaupunki",
+        "Kruunupyy",
+        "Kuhmo",
+        "Kuhmoinen",
+        "Kumlinge",
+        "Kuopio",
+        "Kuortane",
+        "Kurikka",
+        "Kustavi",
+        "Kuusamo",
+        "Outokumpu",
+        "Kyyjärvi",
+        "Kärkölä",
+        "Kärsämäki",
+        "Kökar",
+        "Kemijärvi",
+        "Kemiönsaari",
+        "Lahti",
+        "Laihia",
+        "Laitila",
+        "Lapinlahti",
+        "Lappajärvi",
+        "Lappeenranta",
+        "Lapinjärvi",
+        "Lapua",
+        "Laukaa",
+        "Lemi",
+        "Lemland",
+        "Lempäälä",
+        "Leppävirta",
+        "Lestijärvi",
+        "Lieksa",
+        "Lieto",
+        "Liminka",
+        "Liperi",
+        "Loimaa",
+        "Loppi",
+        "Loviisa",
+        "Luhanka",
+        "Lumijoki",
+        "Lumparland",
+        "Luoto",
+        "Luumäki",
+        "Lohja",
+        "Parainen",
+        "Maalahti",
+        "Maarianhamina",
+        "Marttila",
+        "Masku",
+        "Merijärvi",
+        "Merikarvia",
+        "Miehikkälä",
+        "Mikkeli",
+        "Muhos",
+        "Multia",
+        "Muonio",
+        "Mustasaari",
+        "Muurame",
+        "Mynämäki",
+        "Myrskylä",
+        "Mäntsälä",
+        "Mäntyharju",
+        "Mänttä-Vilppula",
+        "Naantali",
+        "Nakkila",
+        "Nivala",
+        "Nokia",
+        "Nousiainen",
+        "Nurmes",
+        "Nurmijärvi",
+        "Närpiö",
+        "Orimattila",
+        "Oripää",
+        "Orivesi",
+        "Oulainen",
+        "Oulu",
+        "Padasjoki",
+        "Paimio",
+        "Paltamo",
+        "Parikkala",
+        "Parkano",
+        "Pelkosenniemi",
+        "Perho",
+        "Pertunmaa",
+        "Petäjävesi",
+        "Pieksämäki",
+        "Pielavesi",
+        "Pietarsaari",
+        "Pedersören kunta",
+        "Pihtipudas",
+        "Pirkkala",
+        "Polvijärvi",
+        "Pomarkku",
+        "Pori",
+        "Pornainen",
+        "Posio",
+        "Pudasjärvi",
+        "Pukkila",
+        "Punkalaidun",
+        "Puolanka",
+        "Puumala",
+        "Pyhtää",
+        "Pyhäjoki",
+        "Pyhäjärvi",
+        "Pyhäntä",
+        "Pyhäranta",
+        "Pälkäne",
+        "Pöytyä",
+        "Porvoo",
+        "Raahe",
+        "Raisio",
+        "Rantasalmi",
+        "Ranua",
+        "Rauma",
+        "Rautalampi",
+        "Rautavaara",
+        "Rautjärvi",
+        "Reisjärvi",
+        "Riihimäki",
+        "Ristijärvi",
+        "Rovaniemi",
+        "Ruokolahti",
+        "Ruovesi",
+        "Rusko",
+        "Rääkkylä",
+        "Raasepori",
+        "Saarijärvi",
+        "Salla",
+        "Salo",
+        "Saltvik",
+        "Sauvo",
+        "Savitaipale",
+        "Savonlinna",
+        "Savukoski",
+        "Seinäjoki",
+        "Sievi",
+        "Siikainen",
+        "Siikajoki",
+        "Siilinjärvi",
+        "Simo",
+        "Sipoo",
+        "Siuntio",
+        "Sodankylä",
+        "Soini",
+        "Somero",
+        "Sonkajärvi",
+        "Sotkamo",
+        "Sottunga",
+        "Sulkava",
+        "Sund",
+        "Suomussalmi",
+        "Suonenjoki",
+        "Sysmä",
+        "Säkylä",
+        "Vaala",
+        "Sastamala",
+        "Siikalatva",
+        "Taipalsaari",
+        "Taivalkoski",
+        "Taivassalo",
+        "Tammela",
+        "Tampere",
+        "Tervo",
+        "Tervola",
+        "Teuva",
+        "Tohmajärvi",
+        "Toholampi",
+        "Toivakka",
+        "Tornio",
+        "Turku",
+        "Pello",
+        "Tuusniemi",
+        "Tuusula",
+        "Tyrnävä",
+        "Ulvila",
+        "Urjala",
+        "Utajärvi",
+        "Utsjoki",
+        "Uurainen",
+        "Uusikaarlepyy",
+        "Uusikaupunki",
+        "Vaasa",
+        "Valkeakoski",
+        "Valtimo",
+        "Varkaus",
+        "Vehmaa",
+        "Vesanto",
+        "Vesilahti",
+        "Veteli",
+        "Vieremä",
+        "Vihti",
+        "Viitasaari",
+        "Vimpeli",
+        "Virolahti",
+        "Virrat",
+        "Värdö",
+        "Vöyri",
+        "Ylitornio",
+        "Ylivieska",
+        "Ylöjärvi",
+        "Ypäjä",
+        "Ähtäri",
+        "Äänekoski",
+    )
+
+    countries = (
+        "Afganistan",
+        "Alankomaat",
+        "Albania",
+        "Algeria",
+        "Andorra",
+        "Angola",
+        "Antigua ja Barbuda",
+        "Argentiina",
+        "Armenia",
+        "Australia",
+        "Azerbaidžan",
+        "Bahama",
+        "Bahrain",
+        "Bangladesh",
+        "Barbados",
+        "Belgia",
+        "Belize",
+        "Benin",
+        "Bhutan",
+        "Bolivia",
+        "Bosnia ja Hertsegovina",
+        "Botswana",
+        "Brasilia",
+        "Brunei",
+        "Bulgaria",
+        "Burkina",
+        "Faso",
+        "Burundi",
+        "Chile",
+        "Costa",
+        "Rica",
+        "Djibouti",
+        "Dominica",
+        "Dominikaaninen tasavalta",
+        "Ecuador",
+        "Egypti",
+        "El",
+        "Salvador",
+        "Eritrea",
+        "Espanja",
+        "Etelä-Afrikka",
+        "Korean tasavalta",
+        "Etelä-Sudan",
+        "Etiopia",
+        "Fidži",
+        "Filippiinit",
+        "Gabon",
+        "Gambia",
+        "Georgia",
+        "Ghana",
+        "Grenada",
+        "Guatemala",
+        "Guinea-Bissau",
+        "Guinea",
+        "Guyana",
+        "Haiti",
+        "Honduras",
+        "Indonesia",
+        "Intia",
+        "Irak",
+        "Iran",
+        "Irlanti",
+        "Islanti",
+        "Israel",
+        "Italia",
+        "Itä-Timor",
+        "Itävalta",
+        "Jamaika",
+        "Japani",
+        "Jemen",
+        "Jordania",
+        "Kambodža",
+        "Kamerun",
+        "Kanada",
+        "Kap",
+        "Verde",
+        "Kazakstan",
+        "Kenia",
+        "Keski-Afrikan tasavalta",
+        "Kiina",
+        "Kirgisia",
+        "Kiribati",
+        "Kolumbia",
+        "Komorit",
+        "Kongon demokraattinen tasavalta",
+        "Kongon tasavalta",
+        "Kosovo",
+        "Kreikka",
+        "Kroatia",
+        "Kuuba",
+        "Kuwait",
+        "Kypros",
+        "Laos",
+        "Latvia",
+        "Lesotho",
+        "Libanon",
+        "Liberia",
+        "Libya",
+        "Liechtenstein",
+        "Liettua",
+        "Luxemburg",
+        "Madagaskar",
+        "Malawi",
+        "Malediivit",
+        "Malesia",
+        "Mali",
+        "Malta",
+        "Marokko",
+        "Marshallinsaaret",
+        "Mauritania",
+        "Mauritius",
+        "Meksiko",
+        "Mikronesia",
+        "Moldova",
+        "Monaco",
+        "Mongolia",
+        "Montenegro",
+        "Mosambik",
+        "Myanmar",
+        "Namibia",
+        "Nauru",
+        "Nepal",
+        "Nicaragua",
+        "Nigeria",
+        "Niger",
+        "Norja",
+        "Norsunluurannikko",
+        "Oman",
+        "Pakistan",
+        "Palau",
+        "Panama",
+        "Papua-Uusi-Guinea",
+        "Paraguay",
+        "Peru",
+        "Pohjois-Makedonia",
+        "Korean demokraattinen kansantasavalta",
+        "Portugali",
+        "Puola",
+        "Päiväntasaajan Guinea",
+        "Qatar",
+        "Ranska",
+        "Romania",
+        "Ruanda",
+        "Ruotsi",
+        "Saint Kitts ja Nevis",
+        "Saint Lucia",
+        "Saint Vincent ja Grenadiinit",
+        "Saksa",
+        "Salomonsaaret",
+        "Sambia",
+        "Samoa",
+        "San Marino",
+        "São Tomé ja Príncipe",
+        "Saudi-Arabia",
+        "Senegal",
+        "Serbia",
+        "Seychellit",
+        "Sierra",
+        "Leone",
+        "Singapore",
+        "Slovakia",
+        "Slovenia",
+        "Somalia",
+        "Sri",
+        "Lanka",
+        "Sudan",
+        "Suomi",
+        "Suriname",
+        "Swazimaa",
+        "Sveitsi",
+        "Syyria",
+        "Tadžikistan",
+        "Tansania",
+        "Tanska",
+        "Thaimaa",
+        "Togo",
+        "Tonga",
+        "Trinidad ja Tobago",
+        "Tšad",
+        "Tšekki",
+        "Tunisia",
+        "Turkki",
+        "Turkmenistan",
+        "Tuvalu",
+        "Uganda",
+        "Ukraina",
+        "Unkari",
+        "Uruguay",
+        "Uusi-Seelanti",
+        "Uzbekistan",
+        "Valko-Venäjä",
+        "Vanuatu",
+        "Vatikaanivaltio",
+        "Venezuela",
+        "Venäjä",
+        "Vietnam",
+        "Viro",
+        "Yhdistyneet arabiemiirikunnat",
+        "Yhdistynyt kuningaskunta",
+        "Yhdysvallat",
+        "Zimbabwe",
+    )
+
+    # Data from Finnish legislation:
+    # https://www.finlex.fi/fi/laki/alkup/2019/20190978
+    states = (
+        "Ahvenanmaa",
+        "Etelä-Karjala",
+        "Etelä-Pohjanmaa",
+        "Etelä-Savo",
+        "Kainuu",
+        "Kanta-Häme",
+        "Keski-Pohjanmaa",
+        "Keski-Suomi",
+        "Kymenlaakso",
+        "Lappi",
+        "Pirkanmaa",
+        "Pohjanmaa",
+        "Pohjois-Karjala",
+        "Pohjois-Pohjanmaa",
+        "Pohjois-Savo",
+        "Päijät-Häme",
+        "Satakunta",
+        "Uusimaa",
+        "Varsinais-Suomi",
+    )
+
+    street_suffixes = ("tie", "katu", "polku", "kuja", "bulevardi")
+
+    # Prefixes parsed from a street list of Helsinki:
+    # http://kartta.hel.fi/ws/geoserver/avoindata/wfs?outputFormat=application/json&REQUEST=GetFeature&typeNames=avoindata:Helsinki_osoiteluettelo
+
+    street_prefixes = (
+        "Adolf Lindforsin ",
+        "Agnes Sjöbergin ",
+        "Agnetan",
+        "Agricolan",
+        "Ahomäen",
+        "Ahvenkosken",
+        "Aidasmäen",
+        "Agroksen",
+        "Agronomin",
+        "Ahdekaunokin",
+        "Bertel Jungin ",
+        "Bertha Pauligin ",
+        "Betlehemin",
+        "Betoni",
+        "Biologin",
+        "Birger Kaipiaisen ",
+        "Bysantin",
+        "Böstaksen",
+        "Bengalin",
+        "Benktan",
+        "Bergan",
+        "Caloniuksen",
+        "Capellan puisto",
+        "Castrénin",
+        "Chydeniuksen",
+        "Cygnaeuksen",
+        "Dagmarin",
+        "Damaskuksen",
+        "Degermosan",
+        "Disan",
+        "Dosentin",
+        "Dunckerin",
+        "Döbelnin",
+        "Ehrensvärdin",
+        "Eino Leinon ",
+        "Elimäen",
+        "Elisabeth Kochin ",
+        "Eljaksen",
+        "Elon",
+        "Elon",
+        "Edelfeltin",
+        "Eduskunta",
+        "Eerik Pyhän ",
+        "Franzénin",
+        "Fredrikin",
+        "Freesen",
+        "Fabianin",
+        "Fagotti",
+        "Fahlanderin puisto",
+        "Fallin",
+        "Fallkullan",
+        "Fallpakan",
+        "Fastbölen",
+        "Gadolinin",
+        "Gneissi",
+        "Granfeltin",
+        "Gunillan",
+        "Gunnel Nymanin ",
+        "Graniitti",
+        "Gustav Pauligin ",
+        "Gyldénin",
+        "Gotlannin",
+        "Haapa",
+        "Haagan pappilan",
+        "Haahka",
+        "Haakoninlahden",
+        "Haaksi",
+        "Hankasuon",
+        "Hannukselan",
+        "Harakkamyllyn",
+        "Harava",
+        "Harbon",
+        "Ilmattaren",
+        "Ilomäen",
+        "Ilotulitus",
+        "Iltaruskon",
+        "Iltatähden",
+        "Ilves",
+        "Immolan",
+        "Ilkan",
+        "Ida Ekmanin ",
+        "Ies",
+        "Jälsi",
+        "Jämsän",
+        "Jänkä",
+        "Jänne",
+        "Järkäle",
+        "Jätkäsaaren",
+        "Jättiläisen",
+        "Jyvä",
+        "Jägerhornin",
+        "Jäkälä",
+        "Kukkaniityn",
+        "Kolsin",
+        "Kolu",
+        "Kolvi",
+        "Kuhankeittäjän",
+        "Katajaharjun",
+        "Kiitäjän",
+        "Kilpolan",
+        "Kimalais",
+        "Kimmon",
+        "Laajasalon",
+        "Laakavuoren",
+        "Lemun",
+        "Lentokapteenin ",
+        "Lepolan",
+        "Louhen",
+        "Louhikko",
+        "Lukkarimäen",
+        "Laurinniityn",
+        "Lautamiehen",
+        "Mamsellimyllyn",
+        "Mannerheimin",
+        "Maanmittarin",
+        "Maapadon",
+        "Maa",
+        "Maasalon",
+        "Maasälvän",
+        "Maatullin",
+        "Malminkartanon",
+        "Maneesi",
+        "Niittylän",
+        "Niemi",
+        "Niitynperän",
+        "Nikon",
+        "Nils Westermarckin ",
+        "Nordenskiöldin",
+        "Nelikko",
+        "Neon",
+        "Nervanderin",
+        "Neulapadon",
+        "Ostos",
+        "Orapihlaja",
+        "Oras",
+        "Orava",
+        "Osmon",
+        "Osuuskunnan",
+        "Orisaaren",
+        "Ormus",
+        "Orvokki",
+        "Oterman",
+        "Pore",
+        "Porin",
+        "Porkkalan",
+        "Pyörökiven",
+        "Puusepän",
+        "Puuska",
+        "Pohjolan",
+        "Poikasaarten",
+        "Purjetuulen",
+        "Puroniityn",
+        "Rukkilan",
+        "Ruko",
+        "Rukoushuoneen",
+        "Runebergin",
+        "Runoilijan",
+        "Runokylän",
+        "Runonlaulajan",
+        "Rantavaraston",
+        "Rapakiven",
+        "Rapolan",
+        "Santerlan",
+        "Saparon",
+        "Sapilas",
+        "Saramäen",
+        "Saanatunturin",
+        "Sade",
+        "Sahaajan",
+        "Salakka",
+        "Salama",
+        "Salava",
+        "Tuomarinkylän",
+        "Tuulilasin",
+        "Taavetti Laitisen ",
+        "Taavin",
+        "Tahti",
+        "Taimiston",
+        "Tukkisillan",
+        "Tuohikoivun",
+        "Tyynelän",
+        "Tyynylaavan",
+        "Uussillan",
+        "Urheilu",
+        "Urkurin",
+        "Urpu",
+        "Uskalikon",
+        "Usva",
+        "Uudenkaupungin",
+        "Uunilinnun",
+        "Uunisepän",
+        "Uurtajan",
+        "Vanha Raja",
+        "Veropellon",
+        "Veräjämäen",
+        "Vesakko",
+        "Vesalan",
+        "Vellikellon",
+        "Verkko",
+        "Verso",
+        "Vaakalinnun",
+        "Vaarna",
+        "Wavulinin",
+        "Walentin Chorellin ",
+        "Wallinin",
+        "Waseniuksen puisto",
+        "Wecksellin",
+        "Willebrandin",
+        "Winqvistin",
+        "Wäinö Aaltosen ",
+        "Werner Wirénin ",
+        "Yhteiskoulun",
+        "Ylipalon",
+        "Yllästunturin",
+        "Ylä-Fallin ",
+        "Yläkasken",
+        "Ylänkö",
+        "Ylätuvan",
+        "Yrjö-Koskisen ",
+        "Yrjön",
+        "Yrttimaan",
+        "Zaidan",
+    )
+
+    def street_prefix(self) -> str:
+        return self.random_element(self.street_prefixes)
+
+    def city_name(self) -> str:
+        return self.random_element(self.cities)
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.states)
+
+    state = administrative_unit

.venv/lib/python3.12/site-packages/faker/providers/address/fil_PH/__init__.py

@@ -0,0 +1,7 @@
+from ..en_PH import Provider as EnPhAddressProvider
+
+
+class Provider(EnPhAddressProvider):
+    """No difference from Address Provider for en_PH locale"""
+
+    pass

.venv/lib/python3.12/site-packages/faker/providers/address/fr_CA/__init__.py

@@ -0,0 +1,81 @@
+from typing import Any
+
+from ..en_CA import Provider as EnCaProvider
+
+
+class Provider(EnCaProvider):
+    #  Most of the parts are identical to en_CA, we simply override those who are not shared between the two.
+
+    city_prefixes = (
+        "Ville",
+        "Baie",
+        "Saint-",
+        "Sainte-",
+        "Mont-",
+        "La",
+        "Lac-",
+        "L'",
+        "L'Île-",
+    )
+
+    city_suffixes = (
+        "Est",
+        "Ouest",
+        "-sur-Mer",
+    )
+
+    street_prefixes = (
+        "rue",
+        "rue",
+        "chemin",
+        "avenue",
+        "boulevard",
+        "route",
+        "rang",
+        "allé",
+        "montée",
+    )
+
+    provinces = (
+        "Alberta",
+        "Colombie-Britannique",
+        "Manitoba",
+        "Nouveau-Brunswick",
+        "Terre-Neuve-et-Labrador",
+        "Territoires du Nord-Ouest",
+        "Nouvelle-Écosse",
+        "Nunavut",
+        "Ontario",
+        "Île-du-Prince-Édouard",
+        "Québec",
+        "Saskatchewan",
+        "Yukon",
+    )
+
+    street_name_formats = (
+        "{{street_prefix}} {{first_name}}",
+        "{{street_prefix}} {{last_name}}",
+    )
+
+    city_formats = (
+        "{{city_prefix}} {{last_name}}",
+        "{{city_prefix}} {{last_name}}",
+        "{{city_prefix}}-{{city_prefix}}-{{last_name}}",
+        "{{city_prefix}} {{first_name}} {{city_suffix}}",
+        "{{city_prefix}} {{first_name}}",
+        "{{city_prefix}} {{first_name}}",
+        "{{city_prefix}} {{first_name}}",
+        "{{last_name}}",
+        "{{last_name}}",
+        "{{first_name}} {{city_suffix}}",
+        "{{last_name}} {{city_suffix}}",
+    )
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+
+    def street_prefix(self) -> str:
+        """
+        :example: 'rue'
+        """
+        return self.random_element(self.street_prefixes)

.venv/lib/python3.12/site-packages/faker/providers/address/fr_CH/__init__.py

@@ -0,0 +1,367 @@
+from typing import Tuple
+
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_suffixes = (
+        "-des-Bois",
+        "-les-Bains",
+        "-la-Ville",
+        "-Dessus",
+        "-Dessous",
+        " am Rhein",
+        " am See",
+        " am Albis",
+        " an der Aare",
+    )
+    city_prefixes = ("Saint ", "Sainte ", "San ", "Ober", "Unter")
+    street_prefixes = ("rue", "rue", "chemin", "avenue", "boulevard")
+
+    address_formats = ("{{street_address}}\n{{postcode}} {{city}}",)
+
+    building_number_formats = ("%", "%#", "%#", "%#", "%##")
+
+    city_formats = (
+        "{{last_name}}",
+        "{{last_name}}",
+        "{{last_name}}",
+        "{{last_name}}",
+        "{{last_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+        "{{last_name}}-près-{{last_name}}",
+        "{{last_name}}-sur-{{last_name}}",
+        "{{city_prefix}}{{last_name}}",
+        "{{last_name}} ({{canton_code}})",
+    )
+
+    street_address_formats = (
+        "{{street_name}}",
+        "{{street_name}} {{building_number}}",
+        "{{street_name}} {{building_number}}",
+        "{{street_name}} {{building_number}}",
+        "{{street_name}} {{building_number}}",
+        "{{street_name}} {{building_number}}",
+    )
+    street_name_formats = (
+        "{{street_prefix}} {{last_name}}",
+        "{{street_prefix}} {{first_name}} {{last_name}}",
+        "{{street_prefix}} de {{last_name}}",
+    )
+
+    postcode_formats = (
+        "1###",
+        "2###",
+        "3###",
+        "4###",
+        "5###",
+        "6###",
+        "7###",
+        "8###",
+        "9###",
+    )
+
+    cantons = (
+        ("AG", "Argovie"),
+        ("AI", "Appenzell Rhodes-Intérieures"),
+        ("AR", "Appenzell Rhodes-Extérieures"),
+        ("BE", "Berne"),
+        ("BL", "Bâle-Campagne"),
+        ("BS", "Bâle-Ville"),
+        ("FR", "Fribourg"),
+        ("GE", "Genève"),
+        ("GL", "Glaris"),
+        ("GR", "Grisons"),
+        ("JU", "Jura"),
+        ("LU", "Lucerne"),
+        ("NE", "Neuchâtel"),
+        ("NW", "Nidwald"),
+        ("OW", "Obwald"),
+        ("SG", "Saint-Gall"),
+        ("SH", "Schaffhouse"),
+        ("SO", "Soleure"),
+        ("SZ", "Schwytz"),
+        ("TG", "Thurgovie"),
+        ("TI", "Tessin"),
+        ("UR", "Uri"),
+        ("VD", "Vaud"),
+        ("VS", "Valais"),
+        ("ZG", "Zoug"),
+        ("ZH", "Zurich"),
+    )
+
+    countries = (
+        "Afghanistan",
+        "Afrique du sud",
+        "Albanie",
+        "Algérie",
+        "Allemagne",
+        "Andorre",
+        "Angola",
+        "Anguilla",
+        "Antarctique",
+        "Antigua et Barbuda",
+        "Antilles néerlandaises",
+        "Arabie saoudite",
+        "Argentine",
+        "Arménie",
+        "Aruba",
+        "Australie",
+        "Autriche",
+        "Azerbaïdjan",
+        "Bahamas",
+        "Bahrain",
+        "Bangladesh",
+        "Belgique",
+        "Belize",
+        "Benin",
+        "Bermudes (Les)",
+        "Bhoutan",
+        "Biélorussie",
+        "Bolivie",
+        "Bosnie-Herzégovine",
+        "Botswana",
+        "Bouvet (Îles)",
+        "Brunei",
+        "Brésil",
+        "Bulgarie",
+        "Burkina Faso",
+        "Burundi",
+        "Cambodge",
+        "Cameroun",
+        "Canada",
+        "Cap Vert",
+        "Cayman (Îles)",
+        "Chili",
+        "Chine (Rép. pop.)",
+        "Christmas (Île)",
+        "Chypre",
+        "Cocos (Îles)",
+        "Colombie",
+        "Comores",
+        "Cook (Îles)",
+        "Corée du Nord",
+        "Corée, Sud",
+        "Costa Rica",
+        "Croatie",
+        "Cuba",
+        "Côte d'Ivoire",
+        "Danemark",
+        "Djibouti",
+        "Dominique",
+        "Égypte",
+        "El Salvador",
+        "Émirats arabes unis",
+        "Équateur",
+        "Érythrée",
+        "Espagne",
+        "Estonie",
+        "États-Unis",
+        "Ethiopie",
+        "Falkland (Île)",
+        "Fidji (République des)",
+        "Finlande",
+        "France",
+        "Féroé (Îles)",
+        "Gabon",
+        "Gambie",
+        "Ghana",
+        "Gibraltar",
+        "Grenade",
+        "Groenland",
+        "Grèce",
+        "Guadeloupe",
+        "Guam",
+        "Guatemala",
+        "Guinée",
+        "Guinée Equatoriale",
+        "Guinée-Bissau",
+        "Guyane",
+        "Guyane française",
+        "Géorgie",
+        "Géorgie du Sud et Sandwich du Sud (Îles)",
+        "Haïti",
+        "Heard et McDonald (Îles)",
+        "Honduras",
+        "Hong Kong",
+        "Hongrie",
+        "Îles Mineures Éloignées des États-Unis",
+        "Inde",
+        "Indonésie",
+        "Irak",
+        "Iran",
+        "Irlande",
+        "Islande",
+        "Israël",
+        "Italie",
+        "Jamaïque",
+        "Japon",
+        "Jordanie",
+        "Kazakhstan",
+        "Kenya",
+        "Kirghizistan",
+        "Kiribati",
+        "Koweit",
+        "La Barbad",
+        "Laos",
+        "Lesotho",
+        "Lettonie",
+        "Liban",
+        "Libye",
+        "Libéria",
+        "Liechtenstein",
+        "Lithuanie",
+        "Luxembourg",
+        "Macau",
+        "Macédoine du Nord",
+        "Madagascar",
+        "Malaisie",
+        "Malawi",
+        "Maldives (Îles)",
+        "Mali",
+        "Malte",
+        "Mariannes du Nord (Îles)",
+        "Maroc",
+        "Marshall (Îles)",
+        "Martinique",
+        "Maurice",
+        "Mauritanie",
+        "Mayotte",
+        "Mexique",
+        "Micronésie (États fédérés de)",
+        "Moldavie",
+        "Monaco",
+        "Mongolie",
+        "Montserrat",
+        "Mozambique",
+        "Myanmar",
+        "Namibie",
+        "Nauru",
+        "Nepal",
+        "Nicaragua",
+        "Niger",
+        "Nigeria",
+        "Niue",
+        "Norfolk (Îles)",
+        "Norvège",
+        "Nouvelle Calédonie",
+        "Nouvelle-Zélande",
+        "Oman",
+        "Ouganda",
+        "Ouzbékistan",
+        "Pakistan",
+        "Palau",
+        "Panama",
+        "Papouasie-Nouvelle-Guinée",
+        "Paraguay",
+        "Pays-Bas",
+        "Philippines",
+        "Pitcairn (Îles)",
+        "Pologne",
+        "Polynésie française",
+        "Porto Rico",
+        "Portugal",
+        "Pérou",
+        "Qatar",
+        "Roumanie",
+        "Royaume-Uni",
+        "Russie",
+        "Rwanda",
+        "Rép. Dém. du Congo",
+        "République centrafricaine",
+        "République Dominicaine",
+        "République tchèque",
+        "Réunion (La)",
+        "Sahara Occidental",
+        "Saint Pierre et Miquelon",
+        "Saint Vincent et les Grenadines",
+        "Saint-Kitts et Nevis",
+        "Saint-Marin (Rép. de)",
+        "Sainte Hélène",
+        "Sainte Lucie",
+        "Samoa",
+        "Samoa",
+        "Seychelles",
+        "Sierra Leone",
+        "Singapour",
+        "Slovaquie",
+        "Slovénie",
+        "Somalie",
+        "Soudan",
+        "Sri Lanka",
+        "Suisse",
+        "Suriname",
+        "Suède",
+        "Svalbard et Jan Mayen (Îles)",
+        "Swaziland",
+        "Syrie",
+        "São Tomé et Príncipe (Rép.)",
+        "Sénégal",
+        "Tadjikistan",
+        "Taiwan",
+        "Tanzanie",
+        "Tchad",
+        "Territoire britannique de l'océan Indien",
+        "Territoires français du sud",
+        "Thailande",
+        "Timor",
+        "Togo",
+        "Tokelau",
+        "Tonga",
+        "Trinité et Tobago",
+        "Tunisie",
+        "Turkménistan",
+        "Turks et Caïques (Îles)",
+        "Turquie",
+        "Tuvalu",
+        "Ukraine",
+        "Uruguay",
+        "Vanuatu",
+        "Vatican (Etat du)",
+        "Venezuela",
+        "Vierges (Îles)",
+        "Vierges britanniques (Îles)",
+        "Vietnam",
+        "Wallis et Futuna (Îles)",
+        "Yemen",
+        "Yougoslavie",
+        "Zambie",
+        "Zaïre",
+        "Zimbabwe",
+    )
+
+    def street_prefix(self) -> str:
+        """
+        :example: 'rue'
+        """
+        return self.random_element(self.street_prefixes)
+
+    def city_prefix(self) -> str:
+        """
+        :example: 'rue'
+        """
+        return self.random_element(self.city_prefixes)
+
+    def canton(self) -> Tuple[str, str]:
+        """
+        Randomly returns a swiss canton ('Abbreviated' , 'Name').
+        :example: ('VD' . 'Vaud')
+        """
+        return self.random_element(self.cantons)
+
+    def administrative_unit(self) -> str:
+        """
+        Randomly returns a Swiss canton name.
+        :example: 'Vaud'
+        """
+        return self.canton()[1]
+
+    canton_name = administrative_unit
+
+    def canton_code(self) -> str:
+        """
+        Randomly returns a Swiss canton code.
+        :example: 'VD'
+        """
+        return self.canton()[0]

.venv/lib/python3.12/site-packages/faker/providers/address/fr_DZ/__init__.py

@@ -0,0 +1,355 @@
+from typing import Tuple
+
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    """Address provider for fr_DZ locale."""
+
+    # Source: https://fr.wikipedia.org/wiki/Wilayas_d%27Alg%C3%A9rie
+    wilayas: Tuple[str, ...] = (
+        "Adrar",
+        "Chlef",
+        "Laghouat",
+        "Oum El Bouaghi",
+        "Batna",
+        "Béjaïa",
+        "Biskra",
+        "Béchar",
+        "Blida",
+        "Bouira",
+        "Tamanrasset",
+        "Tébessa",
+        "Tlemcen",
+        "Tiaret",
+        "Tizi Ouzou",
+        "Alger",
+        "Djelfa",
+        "Jijel",
+        "Sétif",
+        "Saïda",
+        "Skikda",
+        "Sidi Bel Abbès",
+        "Annaba",
+        "Guelma",
+        "Constantine",
+        "Médéa",
+        "Mostaganem",
+        "M'Sila",
+        "Mascara",
+        "Ouargla",
+        "Oran",
+        "El Bayadh",
+        "Illizi",
+        "Bordj Bou Arreridj",
+        "Boumerdès",
+        "El Tarf",
+        "Tindouf",
+        "Tissemsilt",
+        "El Oued",
+        "Khenchela",
+        "Souk Ahras",
+        "Tipaza",
+        "Mila",
+        "Aïn Defla",
+        "Naâma",
+        "Aïn Témouchent",
+        "Ghardaïa",
+        "Relizane",
+        "Timimoun",
+        "Bordj Badji Mokhtar",
+        "Ouled Djellal",
+        "Béni Abbès",
+        "In Salah",
+        "In Guezzam",
+        "Touggourt",
+        "Djanet",
+        "El Meghaier",
+        "El Menia",
+    )
+
+    # Source: https://github.com/othmanus/algeria-cities
+    cities: Tuple[str, ...] = (
+        # Wilaya 01 - Adrar
+        "Adrar",
+        "Reggane",
+        "Aoulef",
+        "Timimoun",
+        # Wilaya 02 - Chlef
+        "Chlef",
+        "Ténès",
+        "Boukadir",
+        # Wilaya 03 - Laghouat
+        "Laghouat",
+        "Aflou",
+        "Aïn Madhi",
+        # Wilaya 04 - Oum El Bouaghi
+        "Oum El Bouaghi",
+        "Aïn Mlila",
+        "Aïn Beïda",
+        # Wilaya 05 - Batna
+        "Batna",
+        "Barika",
+        "Aïn Touta",
+        "Arris",
+        "N'Gaous",
+        # Wilaya 06 - Béjaïa
+        "Béjaïa",
+        "Akbou",
+        "Kherrata",
+        "Taklast",
+        "Amizour",
+        # Wilaya 07 - Biskra
+        "Biskra",
+        "Tolga",
+        "Sidi Okba",
+        "Zéribet El Oued",
+        # Wilaya 08 - Béchar
+        "Béchar",
+        "Taghit",
+        "Kenadsa",
+        # Wilaya 09 - Blida
+        "Blida",
+        "Boufarik",
+        "Larbaa",
+        "Bouinan",
+        # Wilaya 10 - Bouira
+        "Bouira",
+        "Sour El Ghozlane",
+        "Aïn Bessem",
+        # Wilaya 11 - Tamanrasset
+        "Tamanrasset",
+        "Ablessa",
+        # Wilaya 12 - Tébessa
+        "Tébessa",
+        "Bir El Ater",
+        "El Aouinet",
+        # Wilaya 13 - Tlemcen
+        "Tlemcen",
+        "Maghnia",
+        "Ghazaouet",
+        "Nedroma",
+        "Marsa Ben M'Hidi",
+        # Wilaya 14 - Tiaret
+        "Tiaret",
+        "Sougueur",
+        "Frenda",
+        "Takhmaret",
+        # Wilaya 15 - Tizi Ouzou
+        "Tizi Ouzou",
+        "Draa Ben Khedda",
+        "Azeffoun",
+        "Boughni",
+        "Tigzirt",
+        # Wilaya 16 - Alger
+        "Alger Centre",
+        "Bab El Oued",
+        "La Casbah",
+        "Sidi M'Hamed",
+        "Hussein Dey",
+        "El Harrach",
+        "Rouiba",
+        "Zéralda",
+        "Bir Mourad Raïs",
+        "Bouzaréah",
+        "Chéraga",
+        "Draria",
+        "Bab Ezzouar",
+        "Bordj El Kiffan",
+        "Dar El Beïda",
+        "Aïn Taya",
+        # Wilaya 17 - Djelfa
+        "Djelfa",
+        "Messaad",
+        "Aïn Oussera",
+        "Hassi Bahbah",
+        # Wilaya 18 - Jijel
+        "Jijel",
+        "El Milia",
+        "Taher",
+        "Ziama Mansouriah",
+        # Wilaya 19 - Sétif
+        "Sétif",
+        "El Eulma",
+        "Djemila",
+        "Aïn Arnat",
+        "Bougaa",
+        # Wilaya 20 - Saïda
+        "Saïda",
+        "Aïn El Hadjar",
+        # Wilaya 21 - Skikda
+        "Skikda",
+        "Azzaba",
+        "El Harrouch",
+        "Collo",
+        # Wilaya 22 - Sidi Bel Abbès
+        "Sidi Bel Abbès",
+        "Aïn El Berd",
+        "Marhoum",
+        "Tlemnia",
+        # Wilaya 23 - Annaba
+        "Annaba",
+        "El Bouni",
+        "Aïn Berda",
+        "Sidi Amar",
+        # Wilaya 24 - Guelma
+        "Guelma",
+        "Bouchegouf",
+        "Hammam Debagh",
+        # Wilaya 25 - Constantine
+        "Constantine",
+        "El Khroub",
+        "Didouche Mourad",
+        "Zighoud Youcef",
+        "Aïn Abid",
+        # Wilaya 26 - Médéa
+        "Médéa",
+        "Ksar El Boukhari",
+        "Berrouaghia",
+        "Boughzoul",
+        # Wilaya 27 - Mostaganem
+        "Mostaganem",
+        "Sidi Ali",
+        "Aïn Tédeles",
+        "Mazagran",
+        # Wilaya 28 - M'Sila
+        "M'Sila",
+        "Bou Saâda",
+        "Sidi Aïssa",
+        "Aïn El Melh",
+        # Wilaya 29 - Mascara
+        "Mascara",
+        "Tighennif",
+        "Bouhanifia",
+        "Sig",
+        # Wilaya 30 - Ouargla
+        "Ouargla",
+        "Hassi Messaoud",
+        "Aïn El Beïda",
+        # Wilaya 31 - Oran
+        "Oran",
+        "Arzew",
+        "Aïn El Turk",
+        "Bir El Djir",
+        "Mers El Hadjadj",
+        "Es Sénia",
+        # Wilaya 32 - El Bayadh
+        "El Bayadh",
+        "Brezina",
+        # Wilaya 33 - Illizi
+        "Illizi",
+        "In Amenas",
+        # Wilaya 34 - Bordj Bou Arreridj
+        "Bordj Bou Arreridj",
+        "Ras El Oued",
+        "Aïn Taghrout",
+        # Wilaya 35 - Boumerdès
+        "Boumerdès",
+        "Khemis El Khechna",
+        "Bordj Menaïel",
+        "Dellys",
+        # Wilaya 36 - El Tarf
+        "El Tarf",
+        "El Kala",
+        "Ben M'Hidi",
+        # Wilaya 37 - Tindouf
+        "Tindouf",
+        # Wilaya 38 - Tissemsilt
+        "Tissemsilt",
+        "Khemisti",
+        # Wilaya 39 - El Oued
+        "El Oued",
+        "Guemar",
+        "Hassi Khalifa",
+        "Reguiba",
+        # Wilaya 40 - Khenchela
+        "Khenchela",
+        "Babar",
+        # Wilaya 41 - Souk Ahras
+        "Souk Ahras",
+        "Mdaourouch",
+        "Sedrata",
+        # Wilaya 42 - Tipaza
+        "Tipaza",
+        "Cherchell",
+        "Bou Ismaïl",
+        "Koléa",
+        # Wilaya 43 - Mila
+        "Mila",
+        "Ferdjioua",
+        "Chelghoum Laïd",
+        # Wilaya 44 - Aïn Defla
+        "Aïn Defla",
+        "Khemis Miliana",
+        "El Attaf",
+        "Miliana",
+        # Wilaya 45 - Naâma
+        "Naâma",
+        "Mecheria",
+        "Aïn Sefra",
+        # Wilaya 46 - Aïn Témouchent
+        "Aïn Témouchent",
+        "Béni Saf",
+        "Hammam Bou Hadjar",
+        # Wilaya 47 - Ghardaïa
+        "Ghardaïa",
+        "Guerrara",
+        "Metlili",
+        "El Atteuf",
+        # Wilaya 48 - Relizane
+        "Relizane",
+        "Mazouna",
+        "Oued Rhiou",
+        # New wilayas
+        "Timimoun",
+        "Bordj Badji Mokhtar",
+        "Ouled Djellal",
+        "Béni Abbès",
+        "In Salah",
+        "In Guezzam",
+        "Touggourt",
+        "Djanet",
+        "El Meghaier",
+        "El Menia",
+    )
+
+    street_prefixes: Tuple[str, ...] = (
+        "rue",
+        "avenue",
+        "boulevard",
+        "chemin",
+    )
+
+    building_number_formats: Tuple[str, ...] = ("%", "%#", "%#", "%##")
+
+    postcode_formats: Tuple[str, ...] = tuple(f"{i:02d}###" for i in range(1, 49))
+
+    street_name_formats: Tuple[str, ...] = (
+        "{{street_prefix}} {{last_name}}",
+        "{{street_prefix}} {{first_name}} {{last_name}}",
+        "{{street_prefix}} de {{last_name}}",
+    )
+
+    street_address_formats: Tuple[str, ...] = (
+        "{{building_number}} {{street_name}}",
+        "{{building_number}}, {{street_name}}",
+    )
+
+    address_formats: Tuple[str, ...] = (
+        "{{street_address}} {{city}}",
+        "{{street_address}} - {{city}}",
+        "{{street_address}} {{city}}, {{administrative_unit}}",
+        "{{street_address}}, {{city}}, {{administrative_unit}}",
+        "{{street_address}} {{city}} - {{administrative_unit}}",
+    )
+
+    def street_prefix(self) -> str:
+        return self.random_element(self.street_prefixes)
+
+    def city(self) -> str:
+        return self.random_element(self.cities)
+
+    def administrative_unit(self) -> str:
+        return self.random_element(self.wilayas)
+
+    wilaya = administrative_unit

.venv/lib/python3.12/site-packages/faker/providers/address/fr_FR/__init__.py

@@ -0,0 +1,478 @@
+from typing import Tuple
+
+from .. import Provider as AddressProvider
+
+
+class Provider(AddressProvider):
+    city_suffixes = (
+        "Ville",
+        "Bourg",
+        "-les-Bains",
+        "-sur-Mer",
+        "-la-Forêt",
+        "boeuf",
+        "nec",
+        "dan",
+    )
+    city_prefixes = ("Saint", "Sainte")
+    street_prefixes = ("rue", "rue", "chemin", "avenue", "boulevard")
+    city_formats = (
+        "{{city_prefix}} {{first_name}}",
+        "{{city_prefix}} {{first_name}}{{city_suffix}}",
+        "{{last_name}}",
+        "{{last_name}}",
+        "{{last_name}}",
+        "{{last_name}}",
+        "{{last_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+        "{{last_name}}{{city_suffix}}",
+        "{{last_name}}-sur-{{last_name}}",
+    )
+    street_name_formats = (
+        "{{street_prefix}} {{last_name}}",
+        "{{street_prefix}} {{first_name}} {{last_name}}",
+        "{{street_prefix}} de {{last_name}}",
+    )
+
+    street_address_formats = (
+        "{{street_name}}",
+        "{{building_number}}, {{street_name}}",
+        "{{building_number}}, {{street_name}}",
+        "{{building_number}}, {{street_name}}",
+        "{{building_number}}, {{street_name}}",
+        "{{building_number}}, {{street_name}}",
+    )
+
+    address_formats = ("{{street_address}}\n{{postcode}} {{city}}",)
+
+    building_number_formats = ("%", "%#", "%#", "%#", "%##")
+    countries = (
+        "Afghanistan",
+        "Afrique du sud",
+        "Albanie",
+        "Algérie",
+        "Allemagne",
+        "Andorre",
+        "Angola",
+        "Anguilla",
+        "Antarctique",
+        "Antigua et Barbuda",
+        "Antilles néerlandaises",
+        "Arabie saoudite",
+        "Argentine",
+        "Arménie",
+        "Aruba",
+        "Australie",
+        "Autriche",
+        "Azerbaïdjan",
+        "Bahamas",
+        "Bahrain",
+        "Bangladesh",
+        "Belgique",
+        "Belize",
+        "Benin",
+        "Bermudes (Les)",
+        "Bhoutan",
+        "Biélorussie",
+        "Bolivie",
+        "Bosnie-Herzégovine",
+        "Botswana",
+        "Bouvet (Îles)",
+        "Brunei",
+        "Brésil",
+        "Bulgarie",
+        "Burkina Faso",
+        "Burundi",
+        "Cambodge",
+        "Cameroun",
+        "Canada",
+        "Cap Vert",
+        "Cayman (Îles)",
+        "Chili",
+        "Chine (Rép. pop.)",
+        "Christmas (Île)",
+        "Chypre",
+        "Cocos (Îles)",
+        "Colombie",
+        "Comores",
+        "Cook (Îles)",
+        "Corée du Nord",
+        "Corée, Sud",
+        "Costa Rica",
+        "Croatie",
+        "Cuba",
+        "Côte d'Ivoire",
+        "Danemark",
+        "Djibouti",
+        "Dominique",
+        "Égypte",
+        "El Salvador",
+        "Émirats arabes unis",
+        "Équateur",
+        "Érythrée",
+        "Espagne",
+        "Estonie",
+        "États-Unis",
+        "Ethiopie",
+        "Falkland (Île)",
+        "Fidji (République des)",
+        "Finlande",
+        "France",
+        "Féroé (Îles)",
+        "Gabon",
+        "Gambie",
+        "Ghana",
+        "Gibraltar",
+        "Grenade",
+        "Groenland",
+        "Grèce",
+        "Guadeloupe",
+        "Guam",
+        "Guatemala",
+        "Guinée",
+        "Guinée Equatoriale",
+        "Guinée-Bissau",
+        "Guyane",
+        "Guyane française",
+        "Géorgie",
+        "Géorgie du Sud et Sandwich du Sud (Îles)",
+        "Haïti",
+        "Heard et McDonald (Îles)",
+        "Honduras",
+        "Hong Kong",
+        "Hongrie",
+        "Îles Mineures Éloignées des États-Unis",
+        "Inde",
+        "Indonésie",
+        "Irak",
+        "Iran",
+        "Irlande",
+        "Islande",
+        "Israël",
+        "Italie",
+        "Jamaïque",
+        "Japon",
+        "Jordanie",
+        "Kazakhstan",
+        "Kenya",
+        "Kirghizistan",
+        "Kiribati",
+        "Koweit",
+        "La Barbad",
+        "Laos",
+        "Lesotho",
+        "Lettonie",
+        "Liban",
+        "Libye",
+        "Libéria",
+        "Liechtenstein",
+        "Lithuanie",
+        "Luxembourg",
+        "Macau",
+        "Macédoine du Nord",
+        "Madagascar",
+        "Malaisie",
+        "Malawi",
+        "Maldives (Îles)",
+        "Mali",
+        "Malte",
+        "Mariannes du Nord (Îles)",
+        "Maroc",
+        "Marshall (Îles)",
+        "Martinique",
+        "Maurice",
+        "Mauritanie",
+        "Mayotte",
+        "Mexique",
+        "Micronésie (États fédérés de)",
+        "Moldavie",
+        "Monaco",
+        "Mongolie",
+        "Montserrat",
+        "Mozambique",
+        "Myanmar",
+        "Namibie",
+        "Nauru",
+        "Nepal",
+        "Nicaragua",
+        "Niger",
+        "Nigeria",
+        "Niue",
+        "Norfolk (Îles)",
+        "Norvège",
+        "Nouvelle Calédonie",
+        "Nouvelle-Zélande",
+        "Oman",
+        "Ouganda",
+        "Ouzbékistan",
+        "Pakistan",
+        "Palau",
+        "Panama",
+        "Papouasie-Nouvelle-Guinée",
+        "Paraguay",
+        "Pays-Bas",
+        "Philippines",
+        "Pitcairn (Îles)",
+        "Pologne",
+        "Polynésie française",
+        "Porto Rico",
+        "Portugal",
+        "Pérou",
+        "Qatar",
+        "Roumanie",
+        "Royaume-Uni",
+        "Russie",
+        "Rwanda",
+        "Rép. Dém. du Congo",
+        "République centrafricaine",
+        "République Dominicaine",
+        "République tchèque",
+        "Réunion (La)",
+        "Sahara Occidental",
+        "Saint Pierre et Miquelon",
+        "Saint Vincent et les Grenadines",
+        "Saint-Kitts et Nevis",
+        "Saint-Marin (Rép. de)",
+        "Sainte Hélène",
+        "Sainte Lucie",
+        "Samoa",
+        "Samoa",
+        "Seychelles",
+        "Sierra Leone",
+        "Singapour",
+        "Slovaquie",
+        "Slovénie",
+        "Somalie",
+        "Soudan",
+        "Sri Lanka",
+        "Suisse",
+        "Suriname",
+        "Suède",
+        "Svalbard et Jan Mayen (Îles)",
+        "Swaziland",
+        "Syrie",
+        "São Tomé et Príncipe (Rép.)",
+        "Sénégal",
+        "Tadjikistan",
+        "Taiwan",
+        "Tanzanie",
+        "Tchad",
+        "Territoire britannique de l'océan Indien",
+        "Territoires français du sud",
+        "Thailande",
+        "Timor",
+        "Togo",
+        "Tokelau",
+        "Tonga",
+        "Trinité et Tobago",
+        "Tunisie",
+        "Turkménistan",
+        "Turks et Caïques (Îles)",
+        "Turquie",
+        "Tuvalu",
+        "Ukraine",
+        "Uruguay",
+        "Vanuatu",
+        "Vatican (Etat du)",
+        "Venezuela",
+        "Vierges (Îles)",
+        "Vierges britanniques (Îles)",
+        "Vietnam",
+        "Wallis et Futuna (Îles)",
+        "Yemen",
+        "Yougoslavie",
+        "Zambie",
+        "Zaïre",
+        "Zimbabwe",
+    )
+    regions = (
+        "Alsace",
+        "Aquitaine",
+        "Auvergne",
+        "Bourgogne",
+        "Bretagne",
+        "Centre",
+        "Champagne-Ardenne",
+        "Corse",
+        "Franche-Comté",
+        "Île-de-France",
+        "Languedoc-Roussillon",
+        "Limousin",
+        "Lorraine",
+        "Midi-Pyrénées",
+        "Nord-Pas-de-Calais",
+        "Basse-Normandie",
+        "Haute-Normandie",
+        "Pays-de-Loire",
+        "Picardie",
+        "Poitou-Charentes",
+        "Province-Alpes-Côte d'Azur",
+        "Rhone-Alpes",
+        "Guadeloupe",
+        "Martinique",
+        "Guyane",
+        "Réunion",
+        "Saint-Pierre-et-Miquelon",
+        "Mayotte",
+        "Saint-Barthélémy",
+        "Saint-Martin",
+        "Wallis-et-Futuna",
+        "Polynésie française",
+        "Nouvelle-Calédonie",
+    )
+
+    departments = (
+        ("01", "Ain"),
+        ("02", "Aisne"),
+        ("03", "Allier"),
+        ("04", "Alpes-de-Haute-Provence"),
+        ("05", "Hautes-Alpes"),
+        ("06", "Alpes-Maritimes"),
+        ("07", "Ardèche"),
+        ("08", "Ardennes"),
+        ("09", "Ariège"),
+        ("10", "Aube"),
+        ("11", "Aude"),
+        ("12", "Aveyron"),
+        ("13", "Bouches-du-Rhône"),
+        ("14", "Calvados"),
+        ("15", "Cantal"),
+        ("16", "Charente"),
+        ("17", "Charente-Maritime"),
+        ("18", "Cher"),
+        ("19", "Corrèze"),
+        ("2A", "Corse-du-Sud"),
+        ("2B", "Haute-Corse"),
+        ("21", "Côte-d'Or"),
+        ("22", "Côtes-d'Armor"),
+        ("23", "Creuse"),
+        ("24", "Dordogne"),
+        ("25", "Doubs"),
+        ("26", "Drôme"),
+        ("27", "Eure"),
+        ("28", "Eure-et-Loir"),
+        ("29", "Finistère"),
+        ("30", "Gard"),
+        ("31", "Haute-Garonne"),
+        ("32", "Gers"),
+        ("33", "Gironde"),
+        ("34", "Hérault"),
+        ("35", "Ille-et-Vilaine"),
+        ("36", "Indre"),
+        ("37", "Indre-et-Loire"),
+        ("38", "Isère"),
+        ("39", "Jura"),
+        ("40", "Landes"),
+        ("41", "Loir-et-Cher"),
+        ("42", "Loire"),
+        ("43", "Haute-Loire"),
+        ("44", "Loire-Atlantique"),
+        ("45", "Loiret"),
+        ("46", "Lot"),
+        ("47", "Lot-et-Garonne"),
+        ("48", "Lozère"),
+        ("49", "Maine-et-Loire"),
+        ("50", "Manche"),
+        ("51", "Marne"),
+        ("52", "Haute-Marne"),
+        ("53", "Mayenne"),
+        ("54", "Meurthe-et-Moselle"),
+        ("55", "Meuse"),
+        ("56", "Morbihan"),
+        ("57", "Moselle"),
+        ("58", "Nièvre"),
+        ("59", "Nord"),
+        ("60", "Oise"),
+        ("61", "Orne"),
+        ("62", "Pas-de-Calais"),
+        ("63", "Puy-de-Dôme"),
+        ("64", "Pyrénées-Atlantiques"),
+        ("65", "Hautes-Pyrénées"),
+        ("66", "Pyrénées-Orientales"),
+        ("67", "Bas-Rhin"),
+        ("68", "Haut-Rhin"),
+        ("69", "Rhône"),
+        ("70", "Haute-Saône"),
+        ("71", "Saône-et-Loire"),
+        ("72", "Sarthe"),
+        ("73", "Savoie"),
+        ("74", "Haute-Savoie"),
+        ("75", "Paris"),
+        ("76", "Seine-Maritime"),
+        ("77", "Seine-et-Marne"),
+        ("78", "Yvelines"),
+        ("79", "Deux-Sèvres"),
+        ("80", "Somme"),
+        ("81", "Tarn"),
+        ("82", "Tarn-et-Garonne"),
+        ("83", "Var"),
+        ("84", "Vaucluse"),
+        ("85", "Vendée"),
+        ("86", "Vienne"),
+        ("87", "Haute-Vienne"),
+        ("88", "Vosges"),
+        ("89", "Yonne"),
+        ("90", "Territoire de Belfort"),
+        ("91", "Essonne"),
+        ("92", "Hauts-de-Seine"),
+        ("93", "Seine-Saint-Denis"),
+        ("94", "Val-de-Marne"),
+        ("95", "Val-d'Oise"),
+        ("971", "Guadeloupe"),
+        ("972", "Martinique"),
+        ("973", "Guyane"),
+        ("974", "La Réunion"),
+        ("976", "Mayotte"),
+    )
+
+    def street_prefix(self) -> str:
+        """
+        :example: 'rue'
+        """
+        return self.random_element(self.street_prefixes)
+
+    def city_prefix(self) -> str:
+        """
+        :example: 'rue'
+        """
+        return self.random_element(self.city_prefixes)
+
+    def administrative_unit(self) -> str:
+        """
+        :example: 'Guadeloupe'
+        """
+        return self.random_element(self.regions)
+
+    region = administrative_unit
+
+    def department(self) -> Tuple[str, str]:
+        """
+        Randomly returns a french department ('departmentNumber' , 'departmentName').
+        :example: ('2B' . 'Haute-Corse')
+        """
+        return self.random_element(self.departments)
+
+    def department_name(self) -> str:
+        """
+        Randomly returns a french department name.
+        :example: 'Ardèche'
+        """
+        return self.department()[1]
+
+    def department_number(self) -> str:
+        """
+        Randomly returns a french department number.
+
+        :example: '59'
+        """
+        return self.department()[0]
+
+    def postcode(self) -> str:
+        """
+        Randomly returns a postcode generated from existing french department number.
+        exemple: '33260'
+        """
+        department = self.department_number()
+        if department in ["2A", "2B"]:
+            department = "20"
+        return f"{department}{self.random_number(digits=5 - len(department), fix_len=True)}"