update bots

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

@@ -0,0 +1,802 @@
+from ipaddress import IPV4LENGTH, IPV6LENGTH, IPv4Network, IPv6Address, IPv6Network
+from typing import Dict, List, Optional, Tuple
+
+from ...decode import unidecode
+from ...utils.decorators import lowercase, slugify, slugify_unicode
+from ...utils.distribution import choices_distribution
+from .. import BaseProvider, ElementsType
+from ..lorem.en_US import Provider as USLoremProvider
+
+localized = True
+
+
+class _IPv4Constants:
+    """
+    IPv4 network constants used to group networks into different categories.
+    Structure derived from `ipaddress._IPv4Constants`.
+
+    Excluded network list is updated to comply with current IANA list of
+    private and reserved networks.
+    """
+
+    _network_classes: Dict[str, IPv4Network] = {
+        "a": IPv4Network("0.0.0.0/1"),
+        "b": IPv4Network("128.0.0.0/2"),
+        "c": IPv4Network("192.0.0.0/3"),
+    }
+
+    # Three common private networks from class A, B and CIDR
+    # to generate private addresses from.
+    _private_networks: List[IPv4Network] = [
+        IPv4Network("10.0.0.0/8"),
+        IPv4Network("172.16.0.0/12"),
+        IPv4Network("192.168.0.0/16"),
+    ]
+
+    # List of networks from which IP addresses will never be generated,
+    # includes other private IANA and reserved networks from
+    # https://www.iana.org/assignments/iana-ipv4-special-registry/iana-ipv4-special-registry.xhtml
+    _excluded_networks: List[IPv4Network] = [
+        IPv4Network("0.0.0.0/8"),
+        IPv4Network("100.64.0.0/10"),
+        IPv4Network("127.0.0.0/8"),  # loopback network
+        IPv4Network("169.254.0.0/16"),  # linklocal network
+        IPv4Network("192.0.0.0/24"),
+        IPv4Network("192.0.2.0/24"),
+        IPv4Network("192.31.196.0/24"),
+        IPv4Network("192.52.193.0/24"),
+        IPv4Network("192.88.99.0/24"),
+        IPv4Network("192.175.48.0/24"),
+        IPv4Network("198.18.0.0/15"),
+        IPv4Network("198.51.100.0/24"),
+        IPv4Network("203.0.113.0/24"),
+        IPv4Network("224.0.0.0/4"),  # multicast network
+        IPv4Network("240.0.0.0/4"),
+        IPv4Network("255.255.255.255/32"),
+    ]
+
+
+class Provider(BaseProvider):
+    safe_domain_names: ElementsType[str] = ("example.org", "example.com", "example.net")
+    free_email_domains: ElementsType[str] = ("gmail.com", "yahoo.com", "hotmail.com")
+    tlds: ElementsType[str] = (
+        "com",
+        "com",
+        "com",
+        "com",
+        "com",
+        "com",
+        "biz",
+        "info",
+        "net",
+        "org",
+    )
+    hostname_prefixes: ElementsType[str] = (
+        "db",
+        "srv",
+        "desktop",
+        "laptop",
+        "lt",
+        "email",
+        "web",
+    )
+    uri_pages: ElementsType[str] = (
+        "index",
+        "home",
+        "search",
+        "main",
+        "post",
+        "homepage",
+        "category",
+        "register",
+        "login",
+        "faq",
+        "about",
+        "terms",
+        "privacy",
+        "author",
+    )
+    uri_paths: ElementsType[str] = (
+        "app",
+        "main",
+        "wp-content",
+        "search",
+        "category",
+        "tag",
+        "categories",
+        "tags",
+        "blog",
+        "posts",
+        "list",
+        "explore",
+    )
+    uri_extensions: ElementsType[str] = (
+        ".html",
+        ".html",
+        ".html",
+        ".htm",
+        ".htm",
+        ".php",
+        ".php",
+        ".jsp",
+        ".asp",
+    )
+    http_methods: ElementsType[str] = (
+        "GET",
+        "HEAD",
+        "POST",
+        "PUT",
+        "DELETE",
+        "CONNECT",
+        "OPTIONS",
+        "TRACE",
+        "PATCH",
+    )
+    http_assigned_codes: ElementsType[int] = (
+        100,
+        101,
+        102,
+        103,
+        200,
+        201,
+        202,
+        203,
+        204,
+        205,
+        206,
+        207,
+        208,
+        226,
+        300,
+        301,
+        302,
+        303,
+        304,
+        305,
+        307,
+        308,
+        400,
+        401,
+        402,
+        403,
+        404,
+        405,
+        406,
+        407,
+        408,
+        409,
+        410,
+        411,
+        412,
+        413,
+        414,
+        415,
+        416,
+        417,
+        421,
+        422,
+        423,
+        424,
+        425,
+        426,
+        428,
+        429,
+        431,
+        451,
+        500,
+        501,
+        502,
+        503,
+        504,
+        505,
+        506,
+        507,
+        508,
+        510,
+        511,
+    )
+
+    user_name_formats: ElementsType[str] = (
+        "{{last_name}}.{{first_name}}",
+        "{{first_name}}.{{last_name}}",
+        "{{first_name}}##",
+        "?{{last_name}}",
+    )
+    email_formats: ElementsType[str] = (
+        "{{user_name}}@{{domain_name}}",
+        "{{user_name}}@{{free_email_domain}}",
+    )
+    url_formats: ElementsType[str] = (
+        "www.{{domain_name}}/",
+        "{{domain_name}}/",
+    )
+    image_placeholder_services: ElementsType[str] = (
+        "https://picsum.photos/{width}/{height}",
+        "https://dummyimage.com/{width}x{height}",
+        "https://placekittens.com/{width}/{height}",
+    )
+
+    replacements: Tuple[Tuple[str, str], ...] = ()
+
+    def _to_ascii(self, string: str) -> str:
+        for search, replace in self.replacements:
+            string = string.replace(search, replace)
+
+        string = unidecode(string)
+        return string
+
+    @lowercase
+    def email(self, safe: bool = True, domain: Optional[str] = None) -> str:
+        if domain:
+            email = f"{self.user_name()}@{domain}"
+        elif safe:
+            email = f"{self.user_name()}@{self.safe_domain_name()}"
+        else:
+            pattern: str = self.random_element(self.email_formats)
+            email = "".join(self.generator.parse(pattern).split(" "))
+        return email
+
+    @lowercase
+    def safe_domain_name(self) -> str:
+        return self.random_element(self.safe_domain_names)
+
+    @lowercase
+    def safe_email(self) -> str:
+        return self.user_name() + "@" + self.safe_domain_name()
+
+    @lowercase
+    def free_email(self) -> str:
+        return self.user_name() + "@" + self.free_email_domain()
+
+    @lowercase
+    def company_email(self) -> str:
+        return self.user_name() + "@" + self.domain_name()
+
+    @lowercase
+    def free_email_domain(self) -> str:
+        return self.random_element(self.free_email_domains)
+
+    @lowercase
+    def ascii_email(self) -> str:
+        pattern: str = self.random_element(self.email_formats)
+        return self._to_ascii(
+            "".join(self.generator.parse(pattern).split(" ")),
+        )
+
+    @lowercase
+    def ascii_safe_email(self) -> str:
+        return self._to_ascii(self.user_name() + "@" + self.safe_domain_name())
+
+    @lowercase
+    def ascii_free_email(self) -> str:
+        return self._to_ascii(
+            self.user_name() + "@" + self.free_email_domain(),
+        )
+
+    @lowercase
+    def ascii_company_email(self) -> str:
+        return self._to_ascii(
+            self.user_name() + "@" + self.domain_name(),
+        )
+
+    @slugify_unicode
+    def user_name(self) -> str:
+        pattern: str = self.random_element(self.user_name_formats)
+        return self._to_ascii(self.bothify(self.generator.parse(pattern)).lower())
+
+    @lowercase
+    def hostname(self, levels: int = 1) -> str:
+        """
+        Produce a hostname with specified number of subdomain levels.
+
+        >>> hostname()
+        db-01.nichols-phillips.com
+        >>> hostname(0)
+        laptop-56
+        >>> hostname(2)
+        web-12.williamson-hopkins.jackson.com
+        """
+        hostname_prefix: str = self.random_element(self.hostname_prefixes)
+        hostname_prefix_first_level: str = hostname_prefix + "-" + self.numerify("##")
+        return (
+            hostname_prefix_first_level if levels < 1 else hostname_prefix_first_level + "." + self.domain_name(levels)
+        )
+
+    @lowercase
+    def domain_name(self, levels: int = 1) -> str:
+        """
+        Produce an Internet domain name with the specified number of
+        subdomain levels.
+
+        >>> domain_name()
+        nichols-phillips.com
+        >>> domain_name(2)
+        williamson-hopkins.jackson.com
+        """
+        if levels < 1:
+            raise ValueError("levels must be greater than or equal to 1")
+        if levels == 1:
+            return self.domain_word() + "." + self.tld()
+        return self.domain_word() + "." + self.domain_name(levels - 1)
+
+    @lowercase
+    @slugify_unicode
+    def domain_word(self) -> str:
+        company: str = self.generator.format("company")
+        company_elements: List[str] = company.split(" ")
+        return self._to_ascii(company_elements.pop(0))
+
+    def dga(
+        self,
+        year: Optional[int] = None,
+        month: Optional[int] = None,
+        day: Optional[int] = None,
+        tld: Optional[str] = None,
+        length: Optional[int] = None,
+    ) -> str:
+        """Generates a domain name by given date
+        https://en.wikipedia.org/wiki/Domain_generation_algorithm
+
+        :type year: int
+        :type month: int
+        :type day: int
+        :type tld: str
+        :type length: int
+        :rtype: str
+        """
+
+        domain = ""
+        year = year or self.random_int(min=1, max=9999)
+        month = month or self.random_int(min=1, max=12)
+        day = day or self.random_int(min=1, max=30)
+        tld = tld or self.tld()
+        length = length or self.random_int(min=2, max=63)
+
+        for _ in range(length):
+            year = ((year ^ 8 * year) >> 11) ^ ((year & 0xFFFFFFF0) << 17)
+            month = ((month ^ 4 * month) >> 25) ^ 16 * (month & 0xFFFFFFF8)
+            day = ((day ^ (day << 13)) >> 19) ^ ((day & 0xFFFFFFFE) << 12)
+            domain += chr(((year ^ month ^ day) % 25) + 97)
+
+        return domain + "." + tld
+
+    def tld(self) -> str:
+        return self.random_element(self.tlds)
+
+    def http_method(self) -> str:
+        """Returns random HTTP method
+        https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods
+
+        :rtype: str
+        """
+
+        return self.random_element(self.http_methods)
+
+    def http_status_code(self, include_unassigned: bool = True) -> int:
+        """Returns random HTTP status code
+        https://www.rfc-editor.org/rfc/rfc9110#name-status-codes
+        :param include_unassigned: Whether to include status codes which have
+            not yet been assigned or are unused
+
+        :return: a random three digit status code
+        :rtype: int
+
+        :example: 404
+
+        """
+        if include_unassigned:
+            return self.random_int(min=100, max=599)
+        else:
+            return self.random_element(self.http_assigned_codes)
+
+    def url(self, schemes: Optional[List[str]] = None) -> str:
+        """
+        :param schemes: a list of strings to use as schemes, one will chosen randomly.
+            If None, it will generate http and https urls.
+            Passing an empty list will result in schemeless url generation like "://domain.com".
+        :return: a random url string.
+
+        """
+        if schemes is None:
+            schemes = ["http", "https"]
+
+        pattern: str = f'{self.random_element(schemes) if schemes else ""}://{self.random_element(self.url_formats)}'
+
+        return self.generator.parse(pattern)
+
+    def _get_all_networks_and_weights(self, address_class: Optional[str] = None) -> Tuple[List[IPv4Network], List[int]]:
+        """
+        Produces a 2-tuple of valid IPv4 networks and corresponding relative weights
+
+        :param address_class: IPv4 address class (a, b, or c)
+        """
+        # If `address_class` has an unexpected value, use the whole IPv4 pool
+        if address_class in _IPv4Constants._network_classes.keys():
+            networks_attr = f"_cached_all_class_{address_class}_networks"
+            all_networks = [_IPv4Constants._network_classes[address_class]]  # type: ignore
+        else:
+            networks_attr = "_cached_all_networks"
+            all_networks = [IPv4Network("0.0.0.0/0")]
+
+        # Return cached network and weight data if available
+        weights_attr = f"{networks_attr}_weights"
+        if hasattr(self, networks_attr) and hasattr(self, weights_attr):
+            return getattr(self, networks_attr), getattr(self, weights_attr)
+
+        # Otherwise, compute for list of networks (excluding special networks)
+        all_networks = self._exclude_ipv4_networks(
+            all_networks,
+            _IPv4Constants._excluded_networks,
+        )
+
+        # Then compute for list of corresponding relative weights
+        weights = [network.num_addresses for network in all_networks]
+
+        # Then cache and return results
+        setattr(self, networks_attr, all_networks)
+        setattr(self, weights_attr, weights)
+        return all_networks, weights
+
+    def _get_private_networks_and_weights(
+        self,
+        address_class: Optional[str] = None,
+    ) -> Tuple[List[IPv4Network], List[int]]:
+        """
+        Produces an OrderedDict of valid private IPv4 networks and corresponding relative weights
+
+        :param address_class: IPv4 address class (a, b, or c)
+        """
+        # If `address_class` has an unexpected value, choose a valid value at random
+        if not address_class or address_class not in _IPv4Constants._network_classes.keys():
+            address_class = self.ipv4_network_class()
+
+        # Return cached network and weight data if available for a specific address class
+        networks_attr = f"_cached_private_class_{address_class}_networks"
+        weights_attr = f"{networks_attr}_weights"
+        if hasattr(self, networks_attr) and hasattr(self, weights_attr):
+            return getattr(self, networks_attr), getattr(self, weights_attr)
+
+        # Otherwise, compute for list of private networks (excluding special networks)
+        supernet = _IPv4Constants._network_classes[address_class]
+        private_networks = [subnet for subnet in _IPv4Constants._private_networks if subnet.overlaps(supernet)]
+        private_networks = self._exclude_ipv4_networks(
+            private_networks,
+            _IPv4Constants._excluded_networks,
+        )
+
+        # Then compute for list of corresponding relative weights
+        weights = [network.num_addresses for network in private_networks]
+
+        # Then cache and return results
+        setattr(self, networks_attr, private_networks)
+        setattr(self, weights_attr, weights)
+        return private_networks, weights
+
+    def _get_public_networks_and_weights(
+        self,
+        address_class: Optional[str] = None,
+    ) -> Tuple[List[IPv4Network], List[int]]:
+        """
+        Produces a 2-tuple of valid public IPv4 networks and corresponding relative weights
+
+        :param address_class: IPv4 address class (a, b, or c)
+        """
+        # If `address_class` has an unexpected value, choose a valid value at random
+        if address_class not in _IPv4Constants._network_classes.keys():
+            address_class = self.ipv4_network_class()
+
+        # Return cached network and weight data if available for a specific address class
+        networks_attr = f"_cached_public_class_{address_class}_networks"
+        weights_attr = f"{networks_attr}_weights"
+        if hasattr(self, networks_attr) and hasattr(self, weights_attr):
+            return getattr(self, networks_attr), getattr(self, weights_attr)
+
+        # Otherwise, compute for list of public networks (excluding private and special networks)
+        public_networks = [_IPv4Constants._network_classes[address_class]]  # type: ignore
+        public_networks = self._exclude_ipv4_networks(
+            public_networks,
+            _IPv4Constants._private_networks + _IPv4Constants._excluded_networks,
+        )
+
+        # Then compute for list of corresponding relative weights
+        weights = [network.num_addresses for network in public_networks]
+
+        # Then cache and return results
+        setattr(self, networks_attr, public_networks)
+        setattr(self, weights_attr, weights)
+        return public_networks, weights
+
+    def _random_ipv4_address_from_subnets(
+        self,
+        subnets: List[IPv4Network],
+        weights: Optional[List[int]] = None,
+        network: bool = False,
+    ) -> str:
+        """
+        Produces a random IPv4 address or network with a valid CIDR
+        from within the given subnets using a distribution described
+        by weights.
+
+        :param subnets: List of IPv4Networks to choose from within
+        :param weights: List of weights corresponding to the individual IPv4Networks
+        :param network: Return a network address, and not an IP address
+        :return:
+        """
+        if not subnets:
+            raise ValueError("No subnets to choose from")
+
+        # If the weights argument has an invalid value, default to equal distribution
+        if (
+            isinstance(weights, list)
+            and len(subnets) == len(weights)
+            and all(isinstance(w, (float, int)) for w in weights)
+        ):
+            subnet = choices_distribution(
+                subnets,
+                [float(w) for w in weights],
+                random=self.generator.random,
+                length=1,
+            )[0]
+        else:
+            subnet = self.generator.random.choice(subnets)
+
+        address = str(
+            subnet[
+                self.generator.random.randint(
+                    0,
+                    subnet.num_addresses - 1,
+                )
+            ],
+        )
+
+        if network:
+            address += "/" + str(
+                self.generator.random.randint(
+                    subnet.prefixlen,
+                    subnet.max_prefixlen,
+                )
+            )
+            address = str(IPv4Network(address, strict=False))
+
+        return address
+
+    def _exclude_ipv4_networks(
+        self, networks: List[IPv4Network], networks_to_exclude: List[IPv4Network]
+    ) -> List[IPv4Network]:
+        """
+        Exclude the list of networks from another list of networks
+        and return a flat list of new networks.
+
+        :param networks: List of IPv4 networks to exclude from
+        :param networks_to_exclude: List of IPv4 networks to exclude
+        :returns: Flat list of IPv4 networks
+        """
+        networks_to_exclude.sort(key=lambda x: x.prefixlen)
+        for network_to_exclude in networks_to_exclude:
+
+            def _exclude_ipv4_network(network):
+                """
+                Exclude a single network from another single network
+                and return a list of networks. Network to exclude
+                comes from the outer scope.
+
+                :param network: Network to exclude from
+                :returns: Flat list of IPv4 networks after exclusion.
+                          If exclude fails because networks do not
+                          overlap, a single element list with the
+                          orignal network is returned. If it overlaps,
+                          even partially, the network is excluded.
+                """
+                try:
+                    return list(network.address_exclude(network_to_exclude))
+                except ValueError:
+                    # If networks overlap partially, `address_exclude`
+                    # will fail, but the network still must not be used
+                    # in generation.
+                    if network.overlaps(network_to_exclude):
+                        return []
+                    else:
+                        return [network]
+
+            nested_networks = list(map(_exclude_ipv4_network, networks))
+            networks = [item for nested in nested_networks for item in nested]
+
+        return networks
+
+    def ipv4_network_class(self) -> str:
+        """
+        Returns a IPv4 network class 'a', 'b' or 'c'.
+
+        :returns: IPv4 network class
+        """
+        return self.random_element("abc")
+
+    def ipv4(
+        self,
+        network: bool = False,
+        address_class: Optional[str] = None,
+        private: Optional[str] = None,
+    ) -> str:
+        """
+        Returns a random IPv4 address or network with a valid CIDR.
+
+        :param network: Network address
+        :param address_class: IPv4 address class (a, b, or c)
+        :param private: Public or private
+        :returns: IPv4
+        """
+        if private is True:
+            return self.ipv4_private(address_class=address_class, network=network)
+        elif private is False:
+            return self.ipv4_public(address_class=address_class, network=network)
+        else:
+            all_networks, weights = self._get_all_networks_and_weights(address_class=address_class)
+            return self._random_ipv4_address_from_subnets(all_networks, weights=weights, network=network)
+
+    def ipv4_private(self, network: bool = False, address_class: Optional[str] = None) -> str:
+        """
+        Returns a private IPv4.
+
+        :param network: Network address
+        :param address_class: IPv4 address class (a, b, or c)
+        :returns: Private IPv4
+        """
+        private_networks, weights = self._get_private_networks_and_weights(address_class=address_class)
+        return self._random_ipv4_address_from_subnets(private_networks, weights=weights, network=network)
+
+    def ipv4_public(self, network: bool = False, address_class: Optional[str] = None) -> str:
+        """
+        Returns a public IPv4 excluding private blocks.
+
+        :param network: Network address
+        :param address_class: IPv4 address class (a, b, or c)
+        :returns: Public IPv4
+        """
+        public_networks, weights = self._get_public_networks_and_weights(address_class=address_class)
+        return self._random_ipv4_address_from_subnets(public_networks, weights=weights, network=network)
+
+    def ipv6(self, network: bool = False) -> str:
+        """Produce a random IPv6 address or network with a valid CIDR"""
+        address = str(IPv6Address(self.generator.random.randint(2**IPV4LENGTH, (2**IPV6LENGTH) - 1)))
+        if network:
+            address += "/" + str(self.generator.random.randint(0, IPV6LENGTH))
+            address = str(IPv6Network(address, strict=False))
+        return address
+
+    def mac_address(self, multicast: bool = False) -> str:
+        """
+        Returns a random MAC address.
+
+        :param multicast: Multicast address
+        :returns: MAC Address
+        """
+        mac = [self.generator.random.randint(0x00, 0xFF) for _ in range(0, 5)]
+        if multicast is True:
+            mac.insert(0, self.generator.random.randrange(0x01, 0xFF, 2))
+        else:
+            mac.insert(0, self.generator.random.randrange(0x00, 0xFE, 2))
+        return ":".join("%02x" % x for x in mac)
+
+    def port_number(self, is_system: bool = False, is_user: bool = False, is_dynamic: bool = False) -> int:
+        """Returns a network port number
+        https://tools.ietf.org/html/rfc6335
+
+        :param is_system: System or well-known ports
+        :param is_user: User or registered ports
+        :param is_dynamic: Dynamic / private / ephemeral ports
+        :rtype: int
+        """
+
+        if is_system:
+            return self.random_int(min=0, max=1023)
+        elif is_user:
+            return self.random_int(min=1024, max=49151)
+        elif is_dynamic:
+            return self.random_int(min=49152, max=65535)
+
+        return self.random_int(min=0, max=65535)
+
+    def uri_page(self) -> str:
+        return self.random_element(self.uri_pages)
+
+    def uri_path(self, deep: Optional[int] = None) -> str:
+        deep = deep if deep else self.generator.random.randint(1, 3)
+        return "/".join(
+            self.random_elements(self.uri_paths, length=deep),
+        )
+
+    def uri_extension(self) -> str:
+        return self.random_element(self.uri_extensions)
+
+    def uri(self, schemes: Optional[List[str]] = None, deep: Optional[int] = None) -> str:
+        """
+        :param schemes: a list of strings to use as schemes, one will chosen randomly.
+            If None, it will generate http and https uris.
+            Passing an empty list will result in schemeless uri generation like "://domain.com/index.html".
+        :param deep: an integer specifying how many path components the URI should have..
+        :return: a random url string.
+        """
+        if schemes is None:
+            schemes = ["http", "https"]
+
+        pattern: str = f'{self.random_element(schemes) if schemes else ""}://{self.random_element(self.url_formats)}'
+        path = self.uri_path(deep=deep)
+        page = self.uri_page()
+        extension = self.uri_extension()
+        return f"{self.generator.parse(pattern)}{path}{page}{extension}"
+
+    @slugify
+    def slug(self, value: Optional[str] = None) -> str:
+        """Django algorithm"""
+        if value is None:
+            # Resolve https://github.com/joke2k/faker/issues/2103
+            # Always generate slug with ASCII characters, regardless of locale
+            ext_word_list = USLoremProvider.word_list
+
+            value = self.generator.text(20, ext_word_list=ext_word_list)
+        return value
+
+    def image_url(
+        self,
+        width: Optional[int] = None,
+        height: Optional[int] = None,
+        placeholder_url: Optional[str] = None,
+    ) -> str:
+        """
+        Returns URL to placeholder image
+        Example: http://placehold.it/640x480
+
+        :param width: Optional image width
+        :param height: Optional image height
+        :param placeholder_url: Optional template string of image URLs from custom
+            placeholder service. String must contain ``{width}`` and ``{height}``
+            placeholders, eg: ``https:/example.com/{width}/{height}``.
+        :rtype: str
+        """
+        width_ = width or self.random_int(max=1024)
+        height_ = height or self.random_int(max=1024)
+        if placeholder_url is None:
+            placeholder_url = self.random_element(self.image_placeholder_services)
+        return placeholder_url.format(width=width_, height=height_)
+
+    def iana_id(self) -> str:
+        """Returns IANA Registrar ID
+        https://www.iana.org/assignments/registrar-ids/registrar-ids.xhtml
+
+        :rtype: str
+        """
+
+        return str(self.random_int(min=1, max=8888888))
+
+    def ripe_id(self) -> str:
+        """Returns RIPE Organization ID
+        https://www.ripe.net/manage-ips-and-asns/db/support/organisation-object-in-the-ripe-database
+
+        :rtype: str
+        """
+
+        lex = "?" * self.random_int(min=2, max=4)
+        num = "%" * self.random_int(min=1, max=5)
+        return self.bothify(f"ORG-{lex}{num}-RIPE").upper()
+
+    def nic_handle(self, suffix: str = "FAKE") -> str:
+        """Returns NIC Handle ID
+        https://www.apnic.net/manage-ip/using-whois/guide/person/
+
+        :rtype: str
+        """
+
+        if len(suffix) < 2:
+            raise ValueError("suffix length must be greater than or equal to 2")
+
+        lex = "?" * self.random_int(min=2, max=4)
+        num = "%" * self.random_int(min=1, max=5)
+        return self.bothify(f"{lex}{num}-{suffix}").upper()
+
+    def nic_handles(self, count: int = 1, suffix: str = "????") -> List[str]:
+        """Returns NIC Handle ID list
+
+        :rtype: list[str]
+        """
+
+        return [self.nic_handle(suffix=suffix) for _ in range(count)]

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

@@ -0,0 +1,53 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    replacements = (
+        ("س", "s"),
+        ("ق", "q"),
+        ("ب", "b"),
+        ("خ", "x"),
+        ("ش", "$"),
+        ("َ", "a"),
+        ("ئ", "}"),
+        ("إ", "<"),
+        ("ل", "l"),
+        ("ٰ", "`"),
+        ("ف", "f"),
+        ("و", "w"),
+        ("ض", "D"),
+        ("ي", "y"),
+        ("ُ", "u"),
+        ("ة", "p"),
+        ("ظ", "Z"),
+        ("ث", "v"),
+        ("ـ", "_"),
+        ("ج", "j"),
+        ("د", "d"),
+        ("ح", "H"),
+        ("ا", "A"),
+        ("أ", ">"),
+        ("ر", "r"),
+        ("ى", "Y"),
+        ("ذ", "*"),
+        ("ْ", "o"),
+        ("ن", "n"),
+        ("ّ", "~"),
+        ("ك", "k"),
+        ("ء", "'"),
+        ("ط", "T"),
+        ("ت", "t"),
+        ("ه", "h"),
+        ("ً", "F"),
+        ("ؤ", "&"),
+        ("ٍ", "K"),
+        ("ِ", "i"),
+        ("ص", "S"),
+        ("ٱ", "{"),
+        ("ٌ", "N"),
+        ("م", "m"),
+        ("ز", "z"),
+        ("ع", "E"),
+        ("آ", "|"),
+        ("غ", "g"),
+    )

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

@@ -0,0 +1,38 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    user_name_formats = (
+        "{{last_name_female}}.{{first_name_female}}",
+        "{{last_name_male}}.{{first_name_male}}",
+        "{{first_name_female}}.{{last_name_female}}",
+        "{{first_name_male}}.{{last_name_male}}",
+        "{{first_name}}##",
+        "{{first_name}}_##",
+        "?{{last_name}}",
+        "{{first_name}}{{year}}",
+        "{{first_name}}_{{year}}",
+    )
+
+    email_formats = ("{{user_name}}@{{free_email_domain}}", "{{user_name}}@{{domain_name}}")
+
+    free_email_domains = ("gmail.com", "yahoo.com", "hotmail.com", "mail.ru", "yandex.ru", "box.az", "amail.az")
+
+    tlds = ("az", "com", "biz", "info", "net", "org", "edu")
+
+    replacements = (
+        ("Ə", "e"),
+        ("I", "i"),
+        ("Ü", "u"),
+        ("Ş", "sh"),
+        ("Ç", "c"),
+        ("Ğ", "g"),
+        ("Ö", "o"),
+        ("ə", "e"),
+        ("ı", "i"),
+        ("ü", "u"),
+        ("ş", "sh"),
+        ("ç", "c"),
+        ("ğ", "g"),
+        ("ö", "o"),
+    )

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

@@ -0,0 +1,112 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    user_name_formats = (
+        "{{last_name_female}}.{{first_name_female}}",
+        "{{last_name_male}}.{{first_name_male}}",
+        "{{first_name_female}}.{{last_name_female}}",
+        "{{first_name_male}}.{{last_name_male}}",
+        "{{first_name}}##",
+        "?{{last_name}}",
+        "{{first_name}}{{year}}",
+    )
+
+    email_formats = (
+        "{{user_name}}@{{free_email_domain}}",
+        "{{user_name}}@{{domain_name}}",
+    )
+
+    free_email_domains = (
+        "gmail.com",
+        "yahoo.com",
+        "hotmail.com",
+        "mail.bg",
+        "abv.bg",
+        "dir.bg",
+    )
+
+    tlds = ("bg", "com", "biz", "info", "net", "org", "edu")
+
+    replacements = (
+        ("Б", "b"),
+        ("Г", "r"),
+        ("Д", "d"),
+        ("Ж", "zh"),
+        ("З", "z"),
+        ("И", "i"),
+        ("Й", "i"),
+        ("Л", "l"),
+        ("П", "p"),
+        ("Ф", "f"),
+        ("Ц", "ts"),
+        ("Ч", "ch"),
+        ("Ш", "sh"),
+        ("Щ", "sht"),
+        ("Ъ", "u"),
+        ("Ь", ""),
+        ("Ю", "yu"),
+        ("Я", "ya"),
+        ("б", "b"),
+        ("в", "v"),
+        ("д", "d"),
+        ("ж", "zh"),
+        ("з", "z"),
+        ("и", "i"),
+        ("й", "i"),
+        ("к", "k"),
+        ("л", "l"),
+        ("м", "m"),
+        ("н", "n"),
+        ("п", "p"),
+        ("т", "t"),
+        ("ф", "f"),
+        ("ц", "ts"),
+        ("ч", "ch"),
+        ("ш", "sh"),
+        ("щ", "sht"),
+        ("ъ", "u"),
+        ("ь", ""),
+        ("ю", "yu"),
+        ("я", "ya"),
+        ("Б", "b"),
+        ("Г", "r"),
+        ("Д", "d"),
+        ("Ж", "zh"),
+        ("З", "z"),
+        ("И", "i"),
+        ("Й", "i"),
+        ("Л", "l"),
+        ("П", "p"),
+        ("Ф", "f"),
+        ("Ц", "ts"),
+        ("Ч", "ch"),
+        ("Ш", "sh"),
+        ("Щ", "sht"),
+        ("Ъ", "u"),
+        ("Ь", ""),
+        ("Ю", "yu"),
+        ("Я", "ya"),
+        ("б", "b"),
+        ("в", "v"),
+        ("д", "d"),
+        ("ж", "zh"),
+        ("з", "z"),
+        ("и", "i"),
+        ("й", "i"),
+        ("к", "k"),
+        ("л", "l"),
+        ("м", "m"),
+        ("н", "n"),
+        ("п", "p"),
+        ("т", "t"),
+        ("ф", "f"),
+        ("ц", "ts"),
+        ("ч", "ch"),
+        ("ш", "sh"),
+        ("щ", "sht"),
+        ("ъ", "u"),
+        ("ь", ""),
+        ("ю", "yu"),
+        ("я", "ya"),
+    )

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

@@ -0,0 +1,30 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    """
+    Implement internet provider for ``bn_BD`` locale.
+    """
+
+    free_email_domains = (
+        "gmail.com",
+        "yahoo.com",
+        "hotmail.com",
+        "mail.ru",
+        "yandex.ru",
+        "rambler.ru",
+    )
+
+    tlds = (
+        "com",
+        "com",
+        "com",
+        "com",
+        "com",
+        "com",
+        "biz",
+        "info",
+        "net",
+        "org",
+        "com.bd",
+    )

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

@@ -0,0 +1,27 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "gmail.com",
+        "hotmail.com",
+        "yahoo.com",
+        "outlook.com",
+        "bih.net.ba",
+        "tel.net.ba",
+    )
+
+    tlds = ("ba", "com.ba", "org.ba", "net.ba", "gov.ba", "edu.ba", "unsa.ba")
+
+    replacements = (
+        ("č", "c"),
+        ("Č", "C"),
+        ("ć", "c"),
+        ("Ć", "C"),
+        ("đ", "dj"),
+        ("Đ", "Dj"),
+        ("š", "s"),
+        ("Š", "S"),
+        ("ž", "z"),
+        ("Ž", "Z"),
+    )

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

@@ -0,0 +1,28 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    user_name_formats = (
+        "{{last_name_female}}.{{first_name_female}}",
+        "{{last_name_male}}.{{first_name_male}}",
+        "{{first_name_female}}.{{last_name_female}}",
+        "{{first_name_male}}.{{last_name_male}}",
+        "{{first_name}}##",
+        "?{{last_name}}",
+        "?{{last_name}}",
+        "?{{last_name}}",
+    )
+
+    email_formats = ("{{user_name}}@{{free_email_domain}}",)
+
+    free_email_domains = (
+        "seznam.cz",
+        "gmail.com",
+        "email.cz",
+        "post.cz",
+        "chello.cz",
+        "centrum.cz",
+        "volny.cz",
+    )
+
+    tlds = ("cz", "com", "cz")

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

@@ -0,0 +1,21 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "chello.at",
+        "gmail.com",
+        "gmx.at",
+        "kabsi.at",
+    )
+    tlds = ("at", "co.at", "com", "net", "org")
+
+    replacements = (
+        ("ä", "ae"),
+        ("Ä", "Ae"),
+        ("ö", "oe"),
+        ("Ö", "Oe"),
+        ("ü", "ue"),
+        ("Ü", "Ue"),
+        ("ß", "ss"),
+    )

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

@@ -0,0 +1,28 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "aol.de",
+        "gmail.com",
+        "gmx.de",
+        "googlemail.com",
+        "hotmail.de",
+        "web.de",
+        "yahoo.de",
+    )
+    tlds = ("com", "com", "com", "net", "org", "de", "de", "de")
+
+    replacements = (
+        ("ä", "ae"),
+        ("Ä", "Ae"),
+        ("ö", "oe"),
+        ("Ö", "Oe"),
+        ("ü", "ue"),
+        ("Ü", "Ue"),
+        ("é", "e"),
+        ("É", "E"),
+        ("à", "a"),
+        ("À", "A"),
+        ("ß", "ss"),
+    )

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

@@ -0,0 +1,81 @@
+import re
+
+from faker.utils.decorators import slugify_domain
+
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "hol.gr",
+        "gmail.com",
+        "hotmail.gr",
+        "yahoo.gr",
+        "googlemail.gr",
+        "otenet.gr",
+        "forthnet.gr",
+    )
+    tlds = ("com", "com", "com", "net", "org", "gr", "gr", "gr")
+
+    @slugify_domain
+    def user_name(self) -> str:
+        pattern: str = self.random_element(self.user_name_formats)
+        return latinize(self.bothify(self.generator.parse(pattern)))
+
+    @slugify_domain
+    def domain_word(self) -> str:
+        company = self.generator.format("company")
+        company_elements = company.split(" ")
+        company = latinize(company_elements.pop(0))
+        return company
+
+
+# ``slugify`` doesn't replace greek glyphs.
+
+
+def remove_accents(value: str) -> str:
+    """
+    Remove accents from characters in the given string.
+    """
+    search = "ΆΈΉΊΌΎΏάέήίόύώΪϊΐϋΰ"
+    replace = "ΑΕΗΙΟΥΩαεηιουωΙιιυυ"
+
+    def replace_accented_character(match):
+        matched = match.group(0)
+        if matched in search:
+            return replace[search.find(matched)]
+        return matched
+
+    return re.sub(rf"[{search}]+", replace_accented_character, value)
+
+
+def latinize(value: str) -> str:
+    """
+    Converts (transliterates) greek letters to latin equivalents.
+    """
+
+    def replace_double_character(match):
+        search = ("Θ Χ Ψ " "θ χ ψ " "ΟΥ ΑΥ ΕΥ " "Ου Αυ Ευ " "ου αυ ευ").split()
+        replace = ("TH CH PS " "th ch ps " "OU AU EU " "Ou Au Eu " "ou au eu").split()
+        matched = match.group(0)
+        if matched in search:
+            return replace[search.index(matched)]
+        return matched
+
+    search = "ΑΒΓΔΕΖΗΙΚΛΜΝΞΟΠΡΣΣΤΥΦΩαβγδεζηικλμνξοπρσςτυφω"
+    replace = "AVGDEZIIKLMNXOPRSSTUFOavgdeziiklmnxoprsstyfo"
+
+    def replace_greek_character(match):
+        matched = list(match.group(0))
+        value = (replace[search.find(char)] for char in matched)
+        return "".join(value)
+
+    return re.sub(
+        rf"[{search}]+",
+        replace_greek_character,
+        re.sub(
+            r"([ΘΧΨθχψ]+|ΟΥ|ΑΥ|ΕΥ|Ου|Αυ|Ευ|ου|αυ|ευ)",
+            replace_double_character,
+            remove_accents(value),
+        ),
+    )

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

@@ -0,0 +1,24 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "gmail.com",
+        "yahoo.com",
+        "hotmail.com",
+        "yahoo.com.au",
+        "hotmail.com.au",
+    )
+
+    tlds = (
+        "com",
+        "com.au",
+        "org",
+        "org.au",
+        "net",
+        "net.au",
+        "biz",
+        "info",
+        "edu",
+        "edu.au",
+    )

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

@@ -0,0 +1,29 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    # Data taken from
+    # https://github.com/fzaninotto/Faker/blob/master/src/Faker/Provider/en_GB/Internet.php
+
+    free_email_domains = (
+        "gmail.com",
+        "yahoo.com",
+        "hotmail.com",
+        "yahoo.co.uk",
+        "hotmail.co.uk",
+        "outlook.com",
+    )
+
+    tlds = (
+        "com",
+        "com",
+        "com",
+        "com",
+        "com",
+        "com",
+        "biz",
+        "info",
+        "net",
+        "org",
+        "co.uk",
+    )

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

@@ -0,0 +1,24 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "gmail.com",
+        "yahoo.com",
+        "hotmail.com",
+        "inspire.net.nz",
+        "xtra.co.nz",
+    )
+
+    tlds = (
+        "nz",
+        "co.nz",
+        "org.nz",
+        "kiwi",
+        "kiwi.nz",
+        "geek.nz",
+        "net.nz",
+        "school.nz",
+        "ac.nz",
+        "maori.nz",
+    )

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

@@ -0,0 +1,65 @@
+from collections import OrderedDict
+
+from faker.utils.decorators import lowercase, slugify
+
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    """
+    Provider for internet stuff for en_PH locale
+
+    Free email domains are based on anecdotal evidence and experience. Available TLDs are based on the listed sources.
+    Because of the local company naming scheme, a custom generator is needed to output convincing company domains.
+
+    Sources:
+    - https://en.wikipedia.org/wiki/.ph
+    """
+
+    tlds = (
+        "com",
+        "net",
+        "org",
+        "ph",
+        "com.ph",
+        "net.ph",
+        "org.ph",
+    )
+    safe_email_tlds = tlds
+    free_email_domains = (
+        "gmail.com",
+        "yahoo.com",
+        "zohomail.com",
+    )
+    email_formats = OrderedDict(
+        [
+            ("{{user_name}}@{{domain_name}}", 0.75),
+            ("{{user_name}}@{{free_email_domain}}", 0.25),
+        ]
+    )
+
+    @lowercase
+    @slugify
+    def domain_word(self) -> str:
+        check = self.random_int(0, 99)
+        if check % 100 < 40:
+            company_acronym = self.generator.format("random_company_acronym")
+            if len(company_acronym) == 2:
+                company_type = self.generator.format("company_type")
+                return company_acronym + company_type
+            else:
+                return company_acronym
+        else:
+            if check % 2 == 0:
+                name_part = self.generator.format("last_name")
+            else:
+                name_part = self.generator.format("random_company_adjective")
+            company_noun_chain = self.generator.format("random_company_noun_chain")
+            company_nouns = company_noun_chain.split(" ")
+            if len(company_nouns) == 1:
+                return name_part + company_noun_chain
+            else:
+                company_type = self.generator.format("company_type")
+                company_elements = [name_part] + company_nouns
+                acronym = "".join([word[0] for word in company_elements])
+                return acronym + company_type

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

@@ -0,0 +1,5 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    pass

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

@@ -0,0 +1,21 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    safe_email_tlds = ("com", "net", "ar")
+    tlds = ("com", "com.ar", "com.ar", "net", "org", "net.ar", "ar", "ar")
+    replacements = (
+        ("à", "a"),
+        ("â", "a"),
+        ("ã", "a"),
+        ("á", "a"),
+        ("ç", "c"),
+        ("é", "e"),
+        ("ê", "e"),
+        ("í", "i"),
+        ("ô", "o"),
+        ("ö", "o"),
+        ("õ", "o"),
+        ("ó", "o"),
+        ("ú", "u"),
+    )

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

@@ -0,0 +1,34 @@
+from typing import List
+
+from faker.utils.decorators import lowercase, slugify_unicode
+
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    safe_email_tlds = ("com", "net", "cl", "cl")
+    tlds = ("com", "com", "com", "net", "org", "cl", "cl", "cl")
+    replacements = (
+        ("à", "a"),
+        ("â", "a"),
+        ("ã", "a"),
+        ("á", "a"),
+        ("ç", "c"),
+        ("é", "e"),
+        ("ê", "e"),
+        ("í", "i"),
+        ("ô", "o"),
+        ("ö", "o"),
+        ("õ", "o"),
+        ("ó", "o"),
+        ("ú", "u"),
+    )
+
+    @lowercase
+    @slugify_unicode
+    def domain_word(self) -> str:
+        company: str = self.generator.format("company")
+        company_elements: List[str] = company.split(" ")
+        # select 2 items as companies include prefix
+        name_items = company_elements[:2]
+        return self._to_ascii("".join(name_items))

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

@@ -0,0 +1,21 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    safe_email_tlds = ("com", "net", "es", "es")
+    tlds = ("com", "com", "com", "net", "org", "es", "es", "es")
+    replacements = (
+        ("à", "a"),
+        ("â", "a"),
+        ("ã", "a"),
+        ("á", "a"),
+        ("ç", "c"),
+        ("é", "e"),
+        ("ê", "e"),
+        ("í", "i"),
+        ("ô", "o"),
+        ("ö", "o"),
+        ("õ", "o"),
+        ("ó", "o"),
+        ("ú", "u"),
+    )

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

@@ -0,0 +1,13 @@
+from .. import Provider as BaseProvider
+
+
+class Provider(BaseProvider):
+    safe_email_tlds = ("com", "net", "ir", "org")
+    free_email_domains = (
+        "chmail.ir",
+        "mailfa.com",
+        "gmail.com",
+        "hotmail.com",
+        "yahoo.com",
+    )
+    tlds = ("com", "com", "com", "net", "org", "ir", "ir", "ir")

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

@@ -0,0 +1,15 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "gmail.com",
+        "googlemail.com",
+        "hotmail.com",
+        "suomi24.fi",
+        "kolumbus.fi",
+        "luukku.com",
+        "surffi.net",
+    )
+
+    tlds = ("com", "com", "com", "fi", "fi", "net", "org")

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

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

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

@@ -0,0 +1,35 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    safe_email_tlds = ("org", "com", "net", "ch")
+    free_email_domains = (
+        "gmail.com",
+        "hotmail.fr",
+        "yahoo.fr",
+        "bluewin.ch",
+        "romandie.com",
+        "hispeed.ch",
+        "sunrise.ch",
+        "vtxnet.ch",
+    )
+    tlds = ("com", "com", "com", "net", "org", "ch", "ch", "ch")
+
+    replacements = (
+        ("ä", "ae"),
+        ("à", "a"),
+        ("â", "a"),
+        ("ç", "c"),
+        ("é", "e"),
+        ("è", "e"),
+        ("ê", "e"),
+        ("ë", "e"),
+        ("ï", "i"),
+        ("î", "i"),
+        ("ö", "oe"),
+        ("ô", "o"),
+        ("ü", "ue"),
+        ("ù", "u"),
+        ("ü", "u"),
+        ("ß", "ss"),
+    )

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

@@ -0,0 +1,42 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    safe_email_tlds = ("com", "net", "fr", "fr")
+    free_email_domains = (
+        "voila.fr",
+        "gmail.com",
+        "hotmail.fr",
+        "yahoo.fr",
+        "laposte.net",
+        "free.fr",
+        "sfr.fr",
+        "orange.fr",
+        "bouygtel.fr",
+        "club-internet.fr",
+        "dbmail.com",
+        "live.com",
+        "ifrance.com",
+        "noos.fr",
+        "tele2.fr",
+        "tiscali.fr",
+        "wanadoo.fr",
+    )
+    tlds = ("com", "com", "com", "net", "org", "fr", "fr", "fr")
+    replacements = (
+        ("à", "a"),
+        ("â", "a"),
+        ("ä", "a"),
+        ("ç", "c"),
+        ("é", "e"),
+        ("è", "e"),
+        ("ê", "e"),
+        ("ë", "e"),
+        ("É", "e"),
+        ("ï", "i"),
+        ("î", "i"),
+        ("ô", "o"),
+        ("ö", "o"),
+        ("ù", "u"),
+        ("ü", "u"),
+    )

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

@@ -0,0 +1,33 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "gmail.com",
+        "hotmail.com",
+        "yahoo.com",
+        "net.hr",
+        "zg.t-com.hr",
+        "inet.hr",
+        "t.ht.hr",
+        "vip.hr",
+        "globalnet.hr",
+        "xnet.hr",
+        "yahoo.hr",
+        "zagreb.hr",
+    )
+
+    tlds = ("hr", "com", "com.hr", "info", "org", "net", "biz")
+
+    replacements = (
+        ("č", "c"),
+        ("Č", "C"),
+        ("ć", "c"),
+        ("Ć", "C"),
+        ("đ", "dj"),
+        ("Đ", "Dj"),
+        ("š", "s"),
+        ("Š", "S"),
+        ("ž", "z"),
+        ("Ž", "Z"),
+    )

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

@@ -0,0 +1,37 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "gmail.com",
+        "hotmail.com",
+        "yahoo.com",
+        # Hungarian free email providers (Magyar e-mail szolgáltatók):
+        # https://madweb.hu/a-7-legjobb-ingyenesen-hasznalhato-e-mail-szolgaltatas/
+        "freemail.hu",
+        "citromail.hu",
+        "indamail.hu",
+        "mailbox.hu",
+    )
+
+    tlds = (
+        "hu",
+        "com",
+        "com.hu",
+        "info",
+        "org",
+        "net",
+        "biz",
+    )
+
+    replacements = (
+        ("ö", "o"),
+        ("ü", "u"),
+        ("á", "a"),
+        ("é", "e"),
+        ("í", "i"),
+        ("ó", "o"),
+        ("ő", "o"),
+        ("ú", "u"),
+        ("ű", "u"),
+    )

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

@@ -0,0 +1,28 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    tlds = (
+        # From https://en.wikipedia.org/wiki/List_of_Internet_top-level_domains
+        "com",
+        "org",
+        "net",
+        "int",
+        "edu",
+        "gov",
+        "mil",
+        # From https://id.wikipedia.org/wiki/.id
+        "id",
+        "ac.id",
+        "biz.id",
+        "co.id",
+        "desa.id",
+        "go.id",
+        "mil.id",
+        "my.id",
+        "net.id",
+        "or.id",
+        "ponpes.id",
+        "sch.id",
+        "web.id",
+    )

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

@@ -0,0 +1,36 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    safe_email_tlds = ("com", "net", "eu", "it", "it", "it")
+    free_email_domains = (
+        "libero.it",
+        "libero.it",
+        "libero.it",
+        "tim.it",
+        "tin.it",
+        "alice.it",
+        "virgilio.it",
+        "tiscali.it",
+        "fastwebnet.it",
+        "vodafone.it",
+        "poste.it",
+        "gmail.com",
+        "gmail.com",
+        "gmail.com",
+        "outlook.com",
+        "live.com",
+        "hotmail.com",
+        "hotmail.it",
+        "yahoo.com",
+        "tele2.it",
+    )
+    tlds = ("com", "com", "com", "net", "org", "eu", "it", "it", "it", "it")
+    replacements = (
+        ("à", "a"),
+        ("é", "e"),
+        ("è", "e"),
+        ("ì", "i"),
+        ("ò", "o"),
+        ("ù", "u"),
+    )

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

@@ -0,0 +1,17 @@
+from faker.utils.decorators import slugify
+
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    user_name_formats = (
+        "{{last_romanized_name}}.{{first_romanized_name}}",
+        "{{first_romanized_name}}.{{last_romanized_name}}",
+        "{{first_romanized_name}}##",
+        "?{{last_romanized_name}}",
+    )
+    tlds = ("com", "com", "com", "net", "org", "jp", "jp", "jp")
+
+    @slugify
+    def domain_word(self) -> str:
+        return self.generator.format("last_romanized_name")

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

@@ -0,0 +1,15 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "gmail.com",
+        "daum.net",
+        "hotmail.com",
+        "hanmail.net",
+        "naver.com",
+        "nate.com",
+        "live.com",
+        "dreamwiz.com",
+    )
+    tlds = ("com", "com", "com", "kr", "kr", "net", "org")

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

@@ -0,0 +1,20 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    tlds = ("com", "com", "com", "net", "org", "no", "no", "no", "no", "no")
+
+    replacements = (
+        ("æ", "ae"),
+        ("Æ", "Ae"),
+        ("ø", "oe"),
+        ("Ø", "Oe"),
+        ("å", "aa"),
+        ("Å", "Aa"),
+        ("ä", "ae"),
+        ("Ä", "Ae"),
+        ("ö", "oe"),
+        ("Ö", "Oe"),
+        ("ü", "ue"),
+        ("Ü", "Ue"),
+    )

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

@@ -0,0 +1,26 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "onet.pl",
+        "interia.pl",
+        "gmail.com",
+        "o2.pl",
+        "yahoo.com",
+        "hotmail.com",
+    )
+
+    tlds = ("com", "com", "com", "net", "org", "pl", "pl", "pl")
+
+    replacements = (
+        ("ą", "a"),
+        ("ć", "c"),
+        ("ę", "e"),
+        ("ł", "l"),
+        ("ń", "n"),
+        ("ó", "o"),
+        ("ś", "s"),
+        ("ź", "z"),
+        ("ż", "z"),
+    )

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

@@ -0,0 +1,47 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    safe_email_tlds = ("com", "net", "br", "br")
+    free_email_domains = (
+        "gmail.com",
+        "hotmail.com",
+        "yahoo.com.br",
+        "uol.com.br",
+        "bol.com.br",
+        "terra.com.br",
+        "outlook.com.br",
+        "live.com",
+        "icloud.com",
+    )
+    tlds = (
+        "com",
+        "com",
+        "com",
+        "net",
+        "org",
+        "br",
+        "br",
+        "br",
+        "edu.br",
+        "gov.br",
+        "gov.br",
+        "com.br",
+        "com.br",
+        "com.br",
+    )
+    replacements = (
+        ("à", "a"),
+        ("á", "a"),
+        ("â", "a"),
+        ("ã", "a"),
+        ("ç", "c"),
+        ("é", "e"),
+        ("ê", "e"),
+        ("í", "i"),
+        ("ô", "o"),
+        ("ö", "o"),
+        ("õ", "o"),
+        ("ó", "o"),
+        ("ú", "u"),
+    )

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

@@ -0,0 +1,7 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    safe_email_tlds = ("com", "net", "pt", "pt")
+    free_email_domains = ("gmail.com", "hotmail.com", "clix.pt", "sapo.pt")
+    tlds = ("com", "com", "com", "net", "org", "pt", "pt", "pt")

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

@@ -0,0 +1,28 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    user_name_formats = (
+        "{{last_name_female}}.{{first_name_female}}",
+        "{{last_name_male}}.{{first_name_male}}",
+        "{{first_name_female}}.{{last_name_female}}",
+        "{{first_name_male}}.{{last_name_male}}",
+        "{{first_name}}##",
+        "?{{last_name}}",
+        "?{{last_name}}",
+        "?{{last_name}}",
+    )
+
+    email_formats = ("{{user_name}}@{{free_email_domain}}",)
+
+    free_email_domains = (
+        "email.ro",
+        "gmail.com",
+        "kappa.ro",
+        "acasa.ro",
+        "zzup.ro",
+        "141.ro",
+        "post.ro",
+    )
+
+    tlds = ("ro", "com", "ro")

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

@@ -0,0 +1,100 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    user_name_formats = (
+        "{{last_name_female}}.{{first_name_female}}",
+        "{{last_name_male}}.{{first_name_male}}",
+        "{{first_name_female}}.{{last_name_female}}",
+        "{{first_name_male}}.{{last_name_male}}",
+        "{{first_name}}##",
+        "{{first_name}}_##",
+        "?{{last_name}}",
+        "{{first_name}}{{year}}",
+        "{{first_name}}_{{year}}",
+    )
+
+    email_formats = (
+        "{{user_name}}@{{free_email_domain}}",
+        "{{user_name}}@{{domain_name}}",
+    )
+
+    free_email_domains = (
+        "gmail.com",
+        "yahoo.com",
+        "hotmail.com",
+        "mail.ru",
+        "yandex.ru",
+        "rambler.ru",
+    )
+
+    tlds = ("ru", "com", "biz", "info", "net", "org", "edu")
+
+    replacements = (
+        ("А", "a"),
+        ("Б", "b"),
+        ("В", "v"),
+        ("Г", "g"),
+        ("Д", "d"),
+        ("Е", "e"),
+        ("Ё", "e"),
+        ("Ж", "zh"),
+        ("З", "z"),
+        ("И", "i"),
+        ("Й", ""),
+        ("К", "k"),
+        ("Л", "l"),
+        ("М", "m"),
+        ("Н", "n"),
+        ("О", "o"),
+        ("П", "p"),
+        ("Р", "r"),
+        ("С", "s"),
+        ("Т", "t"),
+        ("У", "u"),
+        ("Ф", "f"),
+        ("Х", "h"),
+        ("Ц", "ts"),
+        ("Ч", "ch"),
+        ("Ш", "sh"),
+        ("Щ", "shch"),
+        ("Ъ", ""),
+        ("Ы", "i"),
+        ("Ь", ""),
+        ("Э", "e"),
+        ("Ю", "yu"),
+        ("Я", "ya"),
+        ("а", "a"),
+        ("б", "b"),
+        ("в", "v"),
+        ("г", "g"),
+        ("д", "d"),
+        ("е", "e"),
+        ("ё", "e"),
+        ("ж", "zh"),
+        ("з", "z"),
+        ("и", "i"),
+        ("й", ""),
+        ("к", "k"),
+        ("л", "l"),
+        ("м", "m"),
+        ("н", "n"),
+        ("о", "o"),
+        ("п", "p"),
+        ("р", "r"),
+        ("с", "s"),
+        ("т", "t"),
+        ("у", "u"),
+        ("ф", "f"),
+        ("х", "h"),
+        ("ц", "ts"),
+        ("ч", "ch"),
+        ("ш", "sh"),
+        ("щ", "shch"),
+        ("ъ", ""),
+        ("ы", "i"),
+        ("ь", ""),
+        ("э", "e"),
+        ("ю", "ju"),
+        ("я", "ja"),
+    )

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

@@ -0,0 +1,31 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    user_name_formats = (
+        "{{last_name_female}}.{{first_name_female}}",
+        "{{last_name_male}}.{{first_name_male}}",
+        "{{first_name_female}}.{{last_name_female}}",
+        "{{first_name_male}}.{{last_name_male}}",
+        "{{first_name}}##",
+        "?{{last_name}}",
+        "?{{last_name}}",
+        "?{{last_name}}",
+    )
+
+    email_formats = ("{{user_name}}@{{free_email_domain}}",)
+
+    free_email_domains = (
+        "zoznam.sk",
+        "gmail.com",
+        "centrum.sk",
+        "post.sk",
+        "chello.sk",
+        "pobox.sk",
+        "szm.sk",
+        "atlas.sk",
+        "azet.sk",
+        "inmail.sk",
+    )
+
+    tlds = ("sk", "com")

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

@@ -0,0 +1,63 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    user_name_formats = (
+        "{{last_name}}.{{first_name_female}}",
+        "{{last_name}}.{{first_name_male}}",
+        "{{first_name_female}}.{{last_name}}",
+        "{{first_name_male}}.{{last_name}}",
+        "{{first_name}}##",
+    )
+
+    email_formats = ("{{user_name}}@{{free_email_domain}}",)
+
+    free_email_domains = (
+        "gmail.com",
+        "siol.net",
+        "email.si",
+        "volja.net",
+    )
+
+    uri_pages = (
+        "index",
+        "domov",
+        "iskanje",
+        "main",
+        "novica",
+        "homepage",
+        "kategorija",
+        "registracija",
+        "login",
+        "faq",
+        "o-nas",
+        "pogoji",
+        "zasebnost",
+        "avtor",
+    )
+    uri_paths = (
+        "app",
+        "main",
+        "wp-content",
+        "iskanje",
+        "kategorija",
+        "novica",
+        "kategorije",
+        "novice",
+        "blog",
+        "komentarji",
+        "seznam",
+    )
+    uri_extensions = (
+        ".html",
+        ".html",
+        ".html",
+        ".htm",
+        ".htm",
+        ".php",
+        ".php",
+        ".jsp",
+        ".asp",
+    )
+
+    tlds = ("si", "com")

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

@@ -0,0 +1,23 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "telia.com",
+        "gmail.com",
+        "swipnet.se",
+        "googlemail.com",
+        "live.se",
+        "spray.se",
+        "yahoo.de",
+    )
+    tlds = ("com", "com", "com", "se", "se", "se", "net", "org")
+
+    replacements = (
+        ("å", "a"),
+        ("Å", "A"),
+        ("ä", "a"),
+        ("Ä", "A"),
+        ("ö", "o"),
+        ("Ö", "O"),
+    )

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

@@ -0,0 +1,32 @@
+from collections import OrderedDict
+
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "hotmail.com",
+        "gmail.com",
+        "outlook.com",
+        "yahoo.com",
+        "ymail.com",
+        "kon.in.th",
+        "icloud.com",
+        "protonmail.com",
+    )
+
+    tlds = OrderedDict(
+        (
+            ("in.th", 100),
+            ("co.th", 80),
+            ("go.th", 40),
+            ("or.th", 40),
+            ("ac.th", 20),
+            ("net.th", 10),
+            ("mi.th", 5),
+            ("co", 10),
+            ("net", 20),
+            ("com", 150),
+            ("org", 50),
+        ),
+    )

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

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

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

@@ -0,0 +1,28 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "hotmail.com",
+        "gmail.com",
+        "yahoo.com",
+        "yandex.com",
+        "yaani.com",
+        "outlook.com",
+    )
+    tlds = ("com", "net", "org", "tr")
+
+    replacements = (
+        ("ı", "i"),
+        ("ğ", "g"),
+        ("ü", "u"),
+        ("ş", "s"),
+        ("ö", "o"),
+        ("ç", "c"),
+        ("Ğ", "G"),
+        ("Ü", "U"),
+        ("Ş", "S"),
+        ("İ", "I"),
+        ("Ö", "O"),
+        ("Ç", "C"),
+    )

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

@@ -0,0 +1,82 @@
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    free_email_domains = (
+        "email.ua",
+        "gmail.com",
+        "gov.ua",
+        "i.ua",
+        "meta.ua",
+        "ukr.net",
+    )
+    tlds = ("com", "info", "net", "org", "ua", "укр")
+
+    replacements = (
+        ("А", "a"),
+        ("Б", "b"),
+        ("В", "v"),
+        ("Г", "h"),
+        ("Ґ", "g"),
+        ("Д", "d"),
+        ("Е", "e"),
+        ("Є", "ye"),
+        ("Ж", "zh"),
+        ("З", "z"),
+        ("И", "y"),
+        ("І", "i"),
+        ("Ї", "yi"),
+        ("Й", "y"),
+        ("К", "k"),
+        ("Л", "l"),
+        ("М", "m"),
+        ("Н", "n"),
+        ("О", "o"),
+        ("П", "p"),
+        ("Р", "r"),
+        ("С", "s"),
+        ("Т", "t"),
+        ("У", "u"),
+        ("Ф", "f"),
+        ("Х", "kh"),
+        ("Ц", "ts"),
+        ("Ч", "ch"),
+        ("Ш", "sh"),
+        ("Щ", "shch"),
+        ("Ь", "ʹ"),
+        ("Ю", "yu"),
+        ("Я", "ya"),
+        ("а", "a"),
+        ("б", "b"),
+        ("в", "v"),
+        ("г", "h"),
+        ("ґ", "g"),
+        ("д", "d"),
+        ("е", "e"),
+        ("є", "ie"),
+        ("ж", "zh"),
+        ("з", "z"),
+        ("и", "y"),
+        ("і", "i"),
+        ("ї", "i"),
+        ("й", "i"),
+        ("к", "k"),
+        ("л", "l"),
+        ("м", "m"),
+        ("н", "n"),
+        ("о", "o"),
+        ("п", "p"),
+        ("р", "r"),
+        ("с", "s"),
+        ("т", "t"),
+        ("у", "u"),
+        ("ф", "f"),
+        ("х", "kh"),
+        ("ц", "ts"),
+        ("ч", "ch"),
+        ("ш", "sh"),
+        ("щ", "shch"),
+        ("ь", "ʹ"),
+        ("ю", "iu"),
+        ("я", "ia"),
+    )

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

@@ -0,0 +1,103 @@
+from collections import OrderedDict
+
+from faker.utils.decorators import slugify
+
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    user_name_formats = (
+        "{{last_romanized_name}}.{{first_romanized_name}}",
+        "{{first_romanized_name}}.{{last_romanized_name}}",
+        "{{first_romanized_name}}##",
+        "?{{last_romanized_name}}",
+    )
+
+    tlds = OrderedDict(
+        (
+            ("cn", 0.8),
+            ("net", 0.1),
+            ("com", 0.05),
+            ("org", 0.05),
+        )
+    )
+
+    second_level_domains = (
+        "ac",
+        "com",
+        "edu",
+        "gov",
+        "mil",
+        "net",
+        "org",
+        "ah",
+        "bj",
+        "cq",
+        "fj",
+        "gd",
+        "gs",
+        "gz",
+        "gx",
+        "ha",
+        "hb",
+        "he",
+        "hi",
+        "hk",
+        "hl",
+        "hn",
+        "jl",
+        "js",
+        "jx",
+        "ln",
+        "mo",
+        "nm",
+        "nx",
+        "qh",
+        "sc",
+        "sd",
+        "sh",
+        "sn",
+        "sx",
+        "tj",
+        "xj",
+        "xz",
+        "yn",
+        "zj",
+    )
+
+    domain_formats = (
+        "##",
+        "??",
+        "{{first_romanized_name}}",
+        "{{last_romanized_name}}",
+        "{{first_romanized_name}}{{last_romanized_name}}",
+        "{{last_romanized_name}}{{last_romanized_name}}",
+        "{{first_romanized_name}}{{first_romanized_name}}",
+    )
+
+    @slugify
+    def domain_word(self) -> str:
+        pattern: str = self.random_element(self.domain_formats)
+        if "#" in pattern or "?" in pattern:
+            return self.bothify(pattern)
+        else:
+            return self.generator.parse(pattern)
+
+    def domain_name(self, levels: int = 1) -> str:
+        if levels < 1:
+            raise ValueError("levels must be greater than or equal to 1")
+        if levels == 1:
+            domain_word = self.domain_word()
+            # Avoids he.cn as seen in issue #687
+            while domain_word in self.second_level_domains:
+                domain_word = self.domain_word()
+            return domain_word + "." + self.tld()
+        elif levels == 2:
+            my_tld = self.tld()
+            if my_tld == "cn":
+                my_second_level: str = self.random_element(self.second_level_domains)
+            else:
+                my_second_level = self.domain_word()
+            return self.domain_word() + "." + my_second_level + "." + my_tld
+        else:
+            return self.domain_word() + "." + self.domain_name(levels - 1)

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

@@ -0,0 +1,17 @@
+from faker.utils.decorators import slugify
+
+from .. import Provider as InternetProvider
+
+
+class Provider(InternetProvider):
+    user_name_formats = (
+        "{{last_romanized_name}}.{{first_romanized_name}}",
+        "{{first_romanized_name}}.{{last_romanized_name}}",
+        "{{first_romanized_name}}##",
+        "?{{last_romanized_name}}",
+    )
+    tlds = ("com", "com", "com", "net", "org", "tw", "tw", "tw")
+
+    @slugify
+    def domain_word(self):
+        return self.generator.format("last_romanized_name")