no venv

10 files changed, 0 insertions, 970 deletions

diff --git a/venv/lib/python3.11/site-packages/faker/providers/misc/__init__.py b/venv/lib/python3.11/site-packages/faker/providers/misc/__init__.py
deleted file mode 100644
index 240249c..0000000
--- a/venv/lib/python3.11/site-packages/faker/providers/misc/__init__.py
+++ /dev/null
@@ -1,737 +0,0 @@
-import csv
-import hashlib
-import io
-import json
-import os
-import re
-import string
-import tarfile
-import uuid
-import zipfile
-
-from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, Type, Union
-
-from faker.exceptions import UnsupportedFeature
-
-from .. import BaseProvider
-from ..python import TypesSpec
-
-localized = True
-
-csv.register_dialect("faker-csv", csv.excel, quoting=csv.QUOTE_ALL)
-
-
-class Provider(BaseProvider):
-    def boolean(self, chance_of_getting_true: int = 50) -> bool:
-        """Generate a random boolean value based on ``chance_of_getting_true``.
-
-        :sample: chance_of_getting_true=25
-        :sample: chance_of_getting_true=50
-        :sample: chance_of_getting_true=75
-        """
-        return self.generator.random.randint(1, 100) <= chance_of_getting_true
-
-    def null_boolean(self) -> Optional[bool]:
-        """Generate ``None``, ``True``, or ``False``, each with equal probability."""
-
-        return {
-            0: None,
-            1: True,
-            -1: False,
-        }[self.generator.random.randint(-1, 1)]
-
-    def binary(self, length: int = (1 * 1024 * 1024)) -> bytes:
-        """Generate a random binary blob of ``length`` bytes.
-
-        If this faker instance has been seeded, performance will be signficiantly reduced, to conform
-        to the seeding.
-
-        :sample: length=64
-        """
-        # If the generator has already been seeded, urandom can't be used
-        if self.generator._is_seeded:
-            blob = [self.generator.random.randrange(256) for _ in range(length)]
-            return bytes(blob)
-
-        # Generator is unseeded anyway, just use urandom
-        return os.urandom(length)
-
-    def md5(self, raw_output: bool = False) -> Union[bytes, str]:
-        """Generate a random MD5 hash.
-
-        If ``raw_output`` is ``False`` (default), a hexadecimal string representation of the MD5 hash
-        will be returned. If ``True``, a ``bytes`` object representation will be returned instead.
-
-        :sample: raw_output=False
-        :sample: raw_output=True
-        """
-        res: hashlib._Hash = hashlib.md5(str(self.generator.random.random()).encode())
-        if raw_output:
-            return res.digest()
-        return res.hexdigest()
-
-    def sha1(self, raw_output: bool = False) -> Union[bytes, str]:
-        """Generate a random SHA-1 hash.
-
-        If ``raw_output`` is ``False`` (default), a hexadecimal string representation of the SHA-1 hash
-        will be returned. If ``True``, a ``bytes`` object representation will be returned instead.
-
-        :sample: raw_output=False
-        :sample: raw_output=True
-        """
-        res: hashlib._Hash = hashlib.sha1(str(self.generator.random.random()).encode())
-        if raw_output:
-            return res.digest()
-        return res.hexdigest()
-
-    def sha256(self, raw_output: bool = False) -> Union[bytes, str]:
-        """Generate a random SHA-256 hash.
-
-        If ``raw_output`` is ``False`` (default), a hexadecimal string representation of the SHA-256 hash
-        will be returned. If ``True``, a ``bytes`` object representation will be returned instead.
-
-        :sample: raw_output=False
-        :sample: raw_output=True
-        """
-        res: hashlib._Hash = hashlib.sha256(str(self.generator.random.random()).encode())
-        if raw_output:
-            return res.digest()
-        return res.hexdigest()
-
-    def uuid4(
-        self,
-        cast_to: Optional[Union[Callable[[uuid.UUID], str], Callable[[uuid.UUID], bytes]]] = str,
-    ) -> Union[bytes, str, uuid.UUID]:
-        """Generate a random UUID4 object and cast it to another type if specified using a callable ``cast_to``.
-
-        By default, ``cast_to`` is set to ``str``.
-
-        May be called with ``cast_to=None`` to return a full-fledged ``UUID``.
-
-        :sample:
-        :sample: cast_to=None
-        """
-        # Based on http://stackoverflow.com/q/41186818
-        generated_uuid: uuid.UUID = uuid.UUID(int=self.generator.random.getrandbits(128), version=4)
-        if cast_to is not None:
-            return cast_to(generated_uuid)
-        return generated_uuid
-
-    def password(
-        self,
-        length: int = 10,
-        special_chars: bool = True,
-        digits: bool = True,
-        upper_case: bool = True,
-        lower_case: bool = True,
-    ) -> str:
-        """Generate a random password of the specified ``length``.
-
-        The arguments ``special_chars``, ``digits``, ``upper_case``, and ``lower_case`` control
-        what category of characters will appear in the generated password. If set to ``True``
-        (default), at least one character from the corresponding category is guaranteed to appear.
-        Special characters are characters from ``!@#$%^&*()_+``, digits are characters from
-        ``0123456789``, and uppercase and lowercase characters are characters from the ASCII set of
-        letters.
-
-        :sample: length=12
-        :sample: length=40, special_chars=False, upper_case=False
-        """
-        choices = ""
-        required_tokens = []
-        if special_chars:
-            required_tokens.append(self.generator.random.choice("!@#$%^&*()_+"))
-            choices += "!@#$%^&*()_+"
-        if digits:
-            required_tokens.append(self.generator.random.choice(string.digits))
-            choices += string.digits
-        if upper_case:
-            required_tokens.append(self.generator.random.choice(string.ascii_uppercase))
-            choices += string.ascii_uppercase
-        if lower_case:
-            required_tokens.append(self.generator.random.choice(string.ascii_lowercase))
-            choices += string.ascii_lowercase
-
-        assert len(required_tokens) <= length, "Required length is shorter than required characters"
-
-        # Generate a first version of the password
-        chars: str = self.random_choices(choices, length=length)  # type: ignore
-
-        # Pick some unique locations
-        random_indexes: Set[int] = set()
-        while len(random_indexes) < len(required_tokens):
-            random_indexes.add(self.generator.random.randint(0, len(chars) - 1))
-
-        # Replace them with the required characters
-        for i, index in enumerate(random_indexes):
-            chars[index] = required_tokens[i]  # type: ignore
-
-        return "".join(chars)
-
-    def zip(
-        self,
-        uncompressed_size: int = 65536,
-        num_files: int = 1,
-        min_file_size: int = 4096,
-        compression: Optional[str] = None,
-    ) -> bytes:
-        """Generate a bytes object containing a random valid zip archive file.
-
-        The number and sizes of files contained inside the resulting archive can be controlled
-        using the following arguments:
-
-        - ``uncompressed_size`` - the total size of files before compression, 16 KiB by default
-        - ``num_files`` - the number of files archived in resulting zip file, 1 by default
-        - ``min_file_size`` - the minimum size of each file before compression, 4 KiB by default
-
-        No compression is used by default, but setting ``compression`` to one of the values listed
-        below will use the corresponding compression type.
-
-        - ``'bzip2'`` or ``'bz2'`` for BZIP2
-        - ``'lzma'`` or ``'xz'`` for LZMA
-        - ``'deflate'``, ``'gzip'``, or ``'gz'`` for GZIP
-
-        :sample: uncompressed_size=256, num_files=4, min_file_size=32
-        :sample: uncompressed_size=256, num_files=32, min_file_size=4, compression='bz2'
-        """
-        if any(
-            [
-                not isinstance(num_files, int) or num_files <= 0,
-                not isinstance(min_file_size, int) or min_file_size <= 0,
-                not isinstance(uncompressed_size, int) or uncompressed_size <= 0,
-            ]
-        ):
-            raise ValueError(
-                "`num_files`, `min_file_size`, and `uncompressed_size` must be positive integers",
-            )
-        if min_file_size * num_files > uncompressed_size:
-            raise AssertionError(
-                "`uncompressed_size` is smaller than the calculated minimum required size",
-            )
-        if compression in ["bzip2", "bz2"]:
-            compression_ = zipfile.ZIP_BZIP2
-        elif compression in ["lzma", "xz"]:
-            compression_ = zipfile.ZIP_LZMA
-        elif compression in ["deflate", "gzip", "gz"]:
-            compression_ = zipfile.ZIP_DEFLATED
-        else:
-            compression_ = zipfile.ZIP_STORED
-
-        zip_buffer = io.BytesIO()
-        remaining_size = uncompressed_size
-        with zipfile.ZipFile(zip_buffer, mode="w", compression=compression_) as zip_handle:
-            for file_number in range(1, num_files + 1):
-                filename = self.generator.pystr() + str(file_number)
-
-                max_allowed_size = remaining_size - (num_files - file_number) * min_file_size
-                if file_number < num_files:
-                    file_size = self.generator.random.randint(min_file_size, max_allowed_size)
-                    remaining_size = remaining_size - file_size
-                else:
-                    file_size = remaining_size
-
-                data = self.generator.binary(file_size)
-                zip_handle.writestr(filename, data)
-        return zip_buffer.getvalue()
-
-    def tar(
-        self,
-        uncompressed_size: int = 65536,
-        num_files: int = 1,
-        min_file_size: int = 4096,
-        compression: Optional[str] = None,
-    ) -> bytes:
-        """Generate a bytes object containing a random valid tar file.
-
-        The number and sizes of files contained inside the resulting archive can be controlled
-        using the following arguments:
-
-        - ``uncompressed_size`` - the total size of files before compression, 16 KiB by default
-        - ``num_files`` - the number of files archived in resulting zip file, 1 by default
-        - ``min_file_size`` - the minimum size of each file before compression, 4 KiB by default
-
-        No compression is used by default, but setting ``compression`` to one of the values listed
-        below will use the corresponding compression type.
-
-        - ``'bzip2'`` or ``'bz2'`` for BZIP2
-        - ``'lzma'`` or ``'xz'`` for LZMA
-        - ``'gzip'`` or ``'gz'`` for GZIP
-
-        :sample: uncompressed_size=256, num_files=4, min_file_size=32
-        :sample: uncompressed_size=256, num_files=32, min_file_size=4, compression='bz2'
-        """
-        if any(
-            [
-                not isinstance(num_files, int) or num_files <= 0,
-                not isinstance(min_file_size, int) or min_file_size <= 0,
-                not isinstance(uncompressed_size, int) or uncompressed_size <= 0,
-            ]
-        ):
-            raise ValueError(
-                "`num_files`, `min_file_size`, and `uncompressed_size` must be positive integers",
-            )
-        if min_file_size * num_files > uncompressed_size:
-            raise AssertionError(
-                "`uncompressed_size` is smaller than the calculated minimum required size",
-            )
-        if compression in ["gzip", "gz"]:
-            mode = "w:gz"
-        elif compression in ["bzip2", "bz2"]:
-            mode = "w:bz2"
-        elif compression in ["lzma", "xz"]:
-            mode = "w:xz"
-        else:
-            mode = "w"
-
-        tar_buffer = io.BytesIO()
-        remaining_size = uncompressed_size
-        with tarfile.open(mode=mode, fileobj=tar_buffer) as tar_handle:
-            for file_number in range(1, num_files + 1):
-                file_buffer = io.BytesIO()
-                filename = self.generator.pystr() + str(file_number)
-
-                max_allowed_size = remaining_size - (num_files - file_number) * min_file_size
-                if file_number < num_files:
-                    file_size = self.generator.random.randint(min_file_size, max_allowed_size)
-                    remaining_size = remaining_size - file_size
-                else:
-                    file_size = remaining_size
-
-                tarinfo = tarfile.TarInfo(name=filename)
-                data = self.generator.binary(file_size)
-                file_buffer.write(data)
-                tarinfo.size = len(file_buffer.getvalue())
-                file_buffer.seek(0)
-                tar_handle.addfile(tarinfo, file_buffer)
-                file_buffer.close()
-        return tar_buffer.getvalue()
-
-    def image(
-        self,
-        size: Tuple[int, int] = (256, 256),
-        image_format: str = "png",
-        hue: Optional[Union[int, Sequence[int], str]] = None,
-        luminosity: Optional[str] = None,
-    ) -> bytes:
-        """Generate an image and draw a random polygon on it using the Python Image Library.
-        Without it installed, this provider won't be functional. Returns the bytes representing
-        the image in a given format.
-
-        The argument ``size`` must be a 2-tuple containing (width, height) in pixels. Defaults to 256x256.
-
-        The argument ``image_format`` can be any valid format to the underlying library like ``'tiff'``,
-        ``'jpeg'``, ``'pdf'`` or ``'png'`` (default). Note that some formats need present system libraries
-        prior to building the Python Image Library.
-        Refer to https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html for details.
-
-        The arguments ``hue`` and ``luminosity`` are the same as in the color provider and are simply forwarded to
-        it to generate both the background and the shape colors. Therefore, you can ask for a "dark blue" image, etc.
-
-        :sample: size=(2, 2), hue='purple', luminosity='bright', image_format='pdf'
-        :sample: size=(16, 16), hue=[90,270], image_format='ico'
-        """
-        try:
-            import PIL.Image
-            import PIL.ImageDraw
-        except ImportError:
-            raise UnsupportedFeature("`image` requires the `Pillow` python library.", "image")
-
-        (width, height) = size
-        image = PIL.Image.new("RGB", size, self.generator.color(hue=hue, luminosity=luminosity))
-        draw = PIL.ImageDraw.Draw(image)
-        draw.polygon(
-            [(self.random_int(0, width), self.random_int(0, height)) for _ in range(self.random_int(3, 12))],
-            fill=self.generator.color(hue=hue, luminosity=luminosity),
-            outline=self.generator.color(hue=hue, luminosity=luminosity),
-        )
-        with io.BytesIO() as fobj:
-            image.save(fobj, format=image_format)
-            fobj.seek(0)
-            return fobj.read()
-
-    def dsv(
-        self,
-        dialect: str = "faker-csv",
-        header: Optional[Sequence[str]] = None,
-        data_columns: Tuple[str, str] = ("{{name}}", "{{address}}"),
-        num_rows: int = 10,
-        include_row_ids: bool = False,
-        **fmtparams: Any,
-    ) -> str:
-        """Generate random delimiter-separated values.
-
-        This method's behavior share some similarities with ``csv.writer``. The ``dialect`` and
-        ``**fmtparams`` arguments are the same arguments expected by ``csv.writer`` to control its
-        behavior, and instead of expecting a file-like object to where output will be written, the
-        output is controlled by additional keyword arguments and is returned as a string.
-
-        The ``dialect`` argument defaults to ``'faker-csv'`` which is the name of a ``csv.excel``
-        subclass with full quoting enabled.
-
-        The ``header`` argument expects a list or a tuple of strings that will serve as the header row
-        if supplied. The ``data_columns`` argument expects a list or a tuple of string tokens, and these
-        string tokens will be passed to  :meth:`pystr_format() <faker.providers.python.Provider.pystr_format>`
-        for data generation. Argument Groups are used to pass arguments to the provider methods.
-        Both ``header`` and ``data_columns`` must be of the same length.
-
-        Example:
-            fake.set_arguments('top_half', {'min_value': 50, 'max_value': 100})
-            fake.dsv(data_columns=('{{ name }}', '{{ pyint:top_half }}'))
-
-        The ``num_rows`` argument controls how many rows of data to generate, and the ``include_row_ids``
-        argument may be set to ``True`` to include a sequential row ID column.
-
-        :sample: dialect='excel', data_columns=('{{name}}', '{{address}}')
-        :sample: dialect='excel-tab', data_columns=('{{name}}', '{{address}}'), include_row_ids=True
-        :sample: data_columns=('{{name}}', '{{address}}'), num_rows=5, delimiter='$'
-        """
-
-        if not isinstance(num_rows, int) or num_rows <= 0:
-            raise ValueError("`num_rows` must be a positive integer")
-        if not isinstance(data_columns, (list, tuple)):
-            raise TypeError("`data_columns` must be a tuple or a list")
-        if header is not None:
-            if not isinstance(header, (list, tuple)):
-                raise TypeError("`header` must be a tuple or a list")
-            if len(header) != len(data_columns):
-                raise ValueError("`header` and `data_columns` must have matching lengths")
-
-        dsv_buffer = io.StringIO()
-        writer = csv.writer(dsv_buffer, dialect=dialect, **fmtparams)
-
-        if header:
-            if include_row_ids:
-                header = list(header)
-                header.insert(0, "ID")
-            writer.writerow(header)
-
-        for row_num in range(1, num_rows + 1):
-            row = [self.generator.pystr_format(column) for column in data_columns]
-            if include_row_ids:
-                row.insert(0, str(row_num))
-
-            writer.writerow(row)
-
-        return dsv_buffer.getvalue()
-
-    def csv(
-        self,
-        header: Optional[Sequence[str]] = None,
-        data_columns: Tuple[str, str] = ("{{name}}", "{{address}}"),
-        num_rows: int = 10,
-        include_row_ids: bool = False,
-    ) -> str:
-        """Generate random comma-separated values.
-
-        For more information on the different arguments of this method, please refer to
-        :meth:`dsv() <faker.providers.misc.Provider.dsv>` which is used under the hood.
-
-        :sample: data_columns=('{{name}}', '{{address}}'), num_rows=10, include_row_ids=False
-        :sample: header=('Name', 'Address', 'Favorite Color'),
-                data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'),
-                num_rows=10, include_row_ids=True
-        """
-        return self.dsv(
-            header=header,
-            data_columns=data_columns,
-            num_rows=num_rows,
-            include_row_ids=include_row_ids,
-            delimiter=",",
-        )
-
-    def tsv(
-        self,
-        header: Optional[Sequence[str]] = None,
-        data_columns: Tuple[str, str] = ("{{name}}", "{{address}}"),
-        num_rows: int = 10,
-        include_row_ids: bool = False,
-    ) -> str:
-        """Generate random tab-separated values.
-
-        For more information on the different arguments of this method, please refer to
-        :meth:`dsv() <faker.providers.misc.Provider.dsv>` which is used under the hood.
-
-        :sample: data_columns=('{{name}}', '{{address}}'), num_rows=10, include_row_ids=False
-        :sample: header=('Name', 'Address', 'Favorite Color'),
-                data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'),
-                num_rows=10, include_row_ids=True
-        """
-        return self.dsv(
-            header=header,
-            data_columns=data_columns,
-            num_rows=num_rows,
-            include_row_ids=include_row_ids,
-            delimiter="\t",
-        )
-
-    def psv(
-        self,
-        header: Optional[Sequence[str]] = None,
-        data_columns: Tuple[str, str] = ("{{name}}", "{{address}}"),
-        num_rows: int = 10,
-        include_row_ids: bool = False,
-    ) -> str:
-        """Generate random pipe-separated values.
-
-        For more information on the different arguments of this method, please refer to
-        :meth:`dsv() <faker.providers.misc.Provider.dsv>` which is used under the hood.
-
-        :sample: data_columns=('{{name}}', '{{address}}'), num_rows=10, include_row_ids=False
-        :sample: header=('Name', 'Address', 'Favorite Color'),
-                data_columns=('{{name}}', '{{address}}', '{{safe_color_name}}'),
-                num_rows=10, include_row_ids=True
-        """
-        return self.dsv(
-            header=header,
-            data_columns=data_columns,
-            num_rows=num_rows,
-            include_row_ids=include_row_ids,
-            delimiter="|",
-        )
-
-    def json_bytes(
-        self,
-        data_columns: Optional[List] = None,
-        num_rows: int = 10,
-        indent: Optional[int] = None,
-        cls: Optional[Type[json.JSONEncoder]] = None,
-    ) -> bytes:
-        """
-        Generate random JSON structure and return as bytes.
-
-        For more information on the different arguments of this method, refer to
-        :meth:`json() <faker.providers.misc.Provider.json>` which is used under the hood.
-        """
-        return self.json(data_columns=data_columns, num_rows=num_rows, indent=indent, cls=cls).encode()
-
-    def json(
-        self,
-        data_columns: Optional[List] = None,
-        num_rows: int = 10,
-        indent: Optional[int] = None,
-        cls: Optional[Type[json.JSONEncoder]] = None,
-    ) -> str:
-        """
-        Generate random JSON structure values.
-
-        Using a dictionary or list of records that is passed as ``data_columns``,
-        define the structure that is used to build JSON structures.  For complex
-        data structures it is recommended to use the dictionary format.
-
-        Data Column Dictionary format:
-            {'key name': 'definition'}
-
-        The definition can be 'provider', 'provider:argument_group', tokenized
-        'string {{ provider:argument_group }}' that is passed to the python
-        provider method pystr_format() for generation, or a fixed '@word'.
-        Using Lists, Tuples, and Dicts as a definition for structure.
-
-        Example:
-            fake.set_arguments('top_half', {'min_value': 50, 'max_value': 100})
-            fake.json(data_columns={'Name': 'name', 'Score': 'pyint:top_half'})
-
-        Data Column List format:
-            [('key name', 'definition', {'arguments'})]
-
-        With the list format the definition can be a list of records, to create
-        a list within the structure data.  For literal entries within the list,
-        set the 'field_name' to None.
-
-        :param data_columns: specification for the data structure
-        :type data_columns: dict
-        :param num_rows: number of rows the returned
-        :type num_rows: int
-        :param indent: number of spaces to indent the fields
-        :type indent: int
-        :param cls: optional json encoder to use for non-standard objects such as datetimes
-        :type cls: json.JSONEncoder
-        :return: Serialized JSON data
-        :rtype: str
-
-        :sample: data_columns={'Spec': '@1.0.1', 'ID': 'pyint',
-                'Details': {'Name': 'name', 'Address': 'address'}}, num_rows=2
-        :sample: data_columns={'Candidates': ['name', 'name', 'name']},
-                num_rows=1
-        :sample: data_columns=[('Name', 'name'), ('Points', 'pyint',
-                {'min_value': 50, 'max_value': 100})], num_rows=1
-        """
-        default_data_columns = {
-            "name": "{{name}}",
-            "residency": "{{address}}",
-        }
-        data_columns: Union[List, Dict] = data_columns if data_columns else default_data_columns
-
-        def process_list_structure(data: Sequence[Any]) -> Any:
-            entry: Dict[str, Any] = {}
-
-            for name, definition, *arguments in data:
-                kwargs = arguments[0] if arguments else {}
-
-                if not isinstance(kwargs, dict):
-                    raise TypeError("Invalid arguments type. Must be a dictionary")
-
-                if name is None:
-                    return self._value_format_selection(definition, **kwargs)
-
-                if isinstance(definition, tuple):
-                    entry[name] = process_list_structure(definition)
-                elif isinstance(definition, (list, set)):
-                    entry[name] = [process_list_structure([item]) for item in definition]
-                else:
-                    entry[name] = self._value_format_selection(definition, **kwargs)
-            return entry
-
-        def process_dict_structure(data: Union[int, float, bool, Dict[str, Any]]) -> Any:
-            entry: Dict[str, Any] = {}
-
-            if isinstance(data, str):
-                return self._value_format_selection(data)
-
-            if isinstance(data, dict):
-                for name, definition in data.items():
-                    if isinstance(definition, (tuple, list, set)):
-                        entry[name] = [process_dict_structure(item) for item in definition]
-                    elif isinstance(definition, (dict, int, float, bool)):
-                        entry[name] = process_dict_structure(definition)
-                    else:
-                        entry[name] = self._value_format_selection(definition)
-                return entry
-
-            return data
-
-        def create_json_structure(data_columns: Union[Dict, List]) -> dict:
-            if isinstance(data_columns, dict):
-                return process_dict_structure(data_columns)
-
-            if isinstance(data_columns, list):
-                return process_list_structure(data_columns)
-
-            raise TypeError("Invalid data_columns type. Must be a dictionary or list")
-
-        if num_rows == 1:
-            return json.dumps(create_json_structure(data_columns), indent=indent, cls=cls)
-
-        data = [create_json_structure(data_columns) for _ in range(num_rows)]
-        return json.dumps(data, indent=indent, cls=cls)
-
-    def xml(
-        self,
-        nb_elements: int = 10,
-        variable_nb_elements: bool = True,
-        value_types: Optional[TypesSpec] = None,
-        allowed_types: Optional[TypesSpec] = None,
-    ) -> str:
-        """
-        Returns some XML.
-
-        :nb_elements: number of elements for dictionary
-        :variable_nb_elements: is use variable number of elements for dictionary
-        :value_types: type of dictionary values
-
-        Note: this provider required xmltodict library installed
-        """
-        try:
-            import xmltodict
-        except ImportError:
-            raise UnsupportedFeature("`xml` requires the `xmltodict` Python library.", "xml")
-        _dict = self.generator.pydict(
-            nb_elements=nb_elements,
-            variable_nb_elements=variable_nb_elements,
-            value_types=value_types,
-            allowed_types=allowed_types,
-        )
-        _dict = {self.generator.word(): _dict}
-        return xmltodict.unparse(_dict)
-
-    def fixed_width(self, data_columns: Optional[list] = None, num_rows: int = 10, align: str = "left") -> str:
-        """
-        Generate random fixed width values.
-
-        Using a list of tuple records that is passed as ``data_columns``, that
-        defines the structure that will be generated. Arguments within the
-        record are provider specific, and should be a dictionary that will be
-        passed to the provider method.
-
-        Data Column List format
-            [('field width', 'definition', {'arguments'})]
-
-        The definition can be 'provider', 'provider:argument_group', tokenized
-        'string {{ provider:argument_group }}' that is passed to the python
-        provider method pystr_format() for generation, or a fixed '@word'.
-        Using Lists, Tuples, and Dicts as a definition for structure.
-
-        Argument Groups can be used to pass arguments to the provider methods,
-        but will override the arguments supplied in the tuple record.
-
-        Example:
-            fake.set_arguments('top_half', {'min_value': 50, 'max_value': 100})
-            fake.fixed_width(data_columns=[(20, 'name'), (3, 'pyint:top_half')])
-
-        :param data_columns: specification for the data structure
-        :type data_columns: list
-        :param num_rows: number of rows the generator will yield
-        :type num_rows: int
-        :param align: positioning of the value. (left, middle, right)
-        :type align: str
-        :return: Serialized Fixed Width data
-        :rtype: str
-
-        :sample: data_columns=[(20, 'name'), (3, 'pyint', {'min_value': 50,
-                'max_value': 100})], align='right', num_rows=2
-        """
-        default_data_columns = [
-            (20, "name"),
-            (3, "pyint", {"max_value": 20}),
-        ]
-        data_columns = data_columns if data_columns else default_data_columns
-        align_map = {
-            "left": "<",
-            "middle": "^",
-            "right": ">",
-        }
-        data = []
-
-        for _ in range(num_rows):
-            row = []
-
-            for width, definition, *arguments in data_columns:
-                kwargs = arguments[0] if arguments else {}
-
-                if not isinstance(kwargs, dict):
-                    raise TypeError("Invalid arguments type. Must be a dictionary")
-
-                result = self._value_format_selection(definition, **kwargs)
-                row.append(f'{result:{align_map.get(align, "<")}{width}}'[:width])
-
-            data.append("".join(row))
-        return "\n".join(data)
-
-    def _value_format_selection(self, definition: str, **kwargs: Any) -> Union[int, str]:
-        """
-        Formats the string in different ways depending on its contents.
-
-        The return can be the '@word' itself, a '{{ token }}' passed to PyStr,
-        or a 'provider:argument_group' format field that returns potentially
-        a non-string type.
-
-        This ensures that Numbers, Boolean types that are generated in the
-        JSON structures in there proper type, and not just strings.
-        """
-
-        # Check for PyStr first as complex strings may start with @
-        if re.match(r".*\{\{.*\}\}.*", definition):
-            return self.generator.pystr_format(definition)
-
-        # Check for fixed @words that won't be generated
-        if re.match(r"^@.*", definition):
-            return definition.lstrip("@")
-
-        # Check if an argument group has been supplied
-        if re.match(r"^[a-zA-Z0-9_-]*:\w", definition):
-            definition, argument_group = definition.split(":")
-            arguments = self.generator.get_arguments(argument_group.strip())
-
-            return self.generator.format(definition.strip(), **arguments)
-
-        # Assume the string is referring to a provider
-        return self.generator.format(definition, **kwargs)
diff --git a/venv/lib/python3.11/site-packages/faker/providers/misc/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/faker/providers/misc/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index c6ff0a8..0000000
--- a/venv/lib/python3.11/site-packages/faker/providers/misc/__pycache__/__init__.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/faker/providers/misc/en_PH/__init__.py b/venv/lib/python3.11/site-packages/faker/providers/misc/en_PH/__init__.py
deleted file mode 100644
index f625e72..0000000
--- a/venv/lib/python3.11/site-packages/faker/providers/misc/en_PH/__init__.py
+++ /dev/null
@@ -1,218 +0,0 @@
-from .. import Provider as MiscProvider
-
-
-class Provider(MiscProvider):
-    """
-    Provider for miscellaneous data for en_PH locale
-
-    This class also houses all other provider methods that would have otherwise been weird to place in another provider.
-    """
-
-    gemstone_names = (
-        "Agate",
-        "Amber",
-        "Amethyst",
-        "Aquamarine",
-        "Citrine",
-        "Diamond",
-        "Emerald",
-        "Garnet",
-        "Jade",
-        "Jasper",
-        "Lapis Lazuli",
-        "Moonstone",
-        "Onyx",
-        "Opal",
-        "Peridot",
-        "Ruby",
-        "Sapphire",
-        "Sardonyx",
-        "Sunstone",
-        "Topaz",
-        "Turquoise",
-        "Zircon",
-    )
-    mountain_names = (
-        "Apo",
-        "Arayat",
-        "Atok",
-        "Banahaw",
-        "Bulusan",
-        "Caraballo",
-        "Cordillera",
-        "Cresta",
-        "Halcon",
-        "Hibok-Hibok",
-        "Iriga",
-        "Kanlaon",
-        "Makiling",
-        "Malinao",
-        "Mariveles",
-        "Matumtum",
-        "Mayon",
-        "Palali",
-        "Palanan",
-        "Pao",
-        "Pinatubo",
-        "Samat",
-        "Sicaba",
-        "Sierra Madre",
-        "Tabayoc",
-    )
-    plant_names = (
-        "Acacia",
-        "Agoho",
-        "Akle",
-        "Anahaw",
-        "Anonas",
-        "Anubing",
-        "Aranga",
-        "Asparagus",
-        "Atis",
-        "Avocado",
-        "Azalea",
-        "Azucena",
-        "Bagtikan",
-        "Bakawan",
-        "Balete",
-        "Balimbing",
-        "Banaba",
-        "Banuyo",
-        "Banyan",
-        "Baticulin",
-        "Batino",
-        "Bauhinia",
-        "Bouganvilla",
-        "Caballero",
-        "Cabbage",
-        "Calantas",
-        "Calumpang",
-        "Camachile",
-        "Camia",
-        "Campanilla",
-        "Carissa",
-        "Carrot",
-        "Catmon",
-        "Cattleya",
-        "Cauliflower",
-        "Celery",
-        "Champaca",
-        "Chico",
-        "Coconut",
-        "Cucumber",
-        "Cypress",
-        "Dao",
-        "Dapdap",
-        "Dita",
-        "Duhat",
-        "Dungon",
-        "Gladiola",
-        "Gloriosa",
-        "Granada",
-        "Guijo",
-        "Gumamela",
-        "Intsia",
-        "Ipil",
-        "Jacaranda",
-        "Jasmine",
-        "Kaimito",
-        "Kalachuchi",
-        "Kalamansi",
-        "Kamagong",
-        "Kamias",
-        "Lanzones",
-        "Lawaan",
-        "Lily",
-        "Lumbayao",
-        "Mabolo",
-        "Macapuno",
-        "Macopa",
-        "Magnolia",
-        "Mahogany",
-        "Malugay",
-        "Mayapis",
-        "Melon",
-        "Milflower",
-        "Molave",
-        "Mushroom",
-        "Mustard",
-        "Narra",
-        "Nipa",
-        "Oleander",
-        "Oliva",
-        "Orchid",
-        "Palm",
-        "Pandan",
-        "Pepper",
-        "Piña",
-        "Raddish",
-        "Rosas",
-        "Sampaguita",
-        "Sampaloc",
-        "Santan",
-        "Santol",
-        "Sineguelas",
-        "Squash",
-        "Supa",
-        "Talisay",
-        "Tamarind",
-        "Tanguile",
-        "Tindalo",
-        "Tulip",
-        "Yakal",
-        "Zinia",
-    )
-    space_object_names = (
-        "Andromeda",
-        "Antares",
-        "Aquarius",
-        "Aries",
-        "Asteroid",
-        "Cancer",
-        "Canopus",
-        "Capricorn",
-        "Comet",
-        "Constellation",
-        "Earth",
-        "Galaxy",
-        "Gemini",
-        "Hercules",
-        "Hydra",
-        "Juno",
-        "Jupiter",
-        "Leo",
-        "Libra",
-        "Mars",
-        "Mercury",
-        "Milky Way",
-        "Neptune",
-        "Orion",
-        "Pisces",
-        "Planet",
-        "Pluto",
-        "Polaris",
-        "Sagittarius",
-        "Saturn",
-        "Scorpio",
-        "Taurus",
-        "Uranus",
-        "Venus",
-        "Virgo",
-        "Zodiac",
-    )
-    random_object_names = gemstone_names + mountain_names + plant_names + space_object_names
-
-    def gemstone_name(self) -> str:
-        return self.random_element(self.gemstone_names)
-
-    def mountain_name(self) -> str:
-        return self.random_element(self.mountain_names)
-
-    def plant_name(self) -> str:
-        return self.random_element(self.plant_names)
-
-    def space_object_name(self) -> str:
-        return self.random_element(self.space_object_names)
-
-    def random_object_name(self) -> str:
-        return self.random_element(self.random_object_names)
diff --git a/venv/lib/python3.11/site-packages/faker/providers/misc/en_PH/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/faker/providers/misc/en_PH/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index 55a5075..0000000
--- a/venv/lib/python3.11/site-packages/faker/providers/misc/en_PH/__pycache__/__init__.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/faker/providers/misc/en_US/__init__.py b/venv/lib/python3.11/site-packages/faker/providers/misc/en_US/__init__.py
deleted file mode 100644
index e074813..0000000
--- a/venv/lib/python3.11/site-packages/faker/providers/misc/en_US/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from .. import Provider as MiscProvider
-
-
-class Provider(MiscProvider):
-    pass
diff --git a/venv/lib/python3.11/site-packages/faker/providers/misc/en_US/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/faker/providers/misc/en_US/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index 8c09680..0000000
--- a/venv/lib/python3.11/site-packages/faker/providers/misc/en_US/__pycache__/__init__.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/faker/providers/misc/fil_PH/__init__.py b/venv/lib/python3.11/site-packages/faker/providers/misc/fil_PH/__init__.py
deleted file mode 100644
index eec4513..0000000
--- a/venv/lib/python3.11/site-packages/faker/providers/misc/fil_PH/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from ..en_PH import Provider as EnPhMiscProvider
-
-
-class Provider(EnPhMiscProvider):
-    """No difference from Misc Provider for en_PH locale (yet)"""
diff --git a/venv/lib/python3.11/site-packages/faker/providers/misc/fil_PH/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/faker/providers/misc/fil_PH/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index 1f3f7b5..0000000
--- a/venv/lib/python3.11/site-packages/faker/providers/misc/fil_PH/__pycache__/__init__.cpython-311.pyc
+++ /dev/null
diff --git a/venv/lib/python3.11/site-packages/faker/providers/misc/tl_PH/__init__.py b/venv/lib/python3.11/site-packages/faker/providers/misc/tl_PH/__init__.py
deleted file mode 100644
index eec4513..0000000
--- a/venv/lib/python3.11/site-packages/faker/providers/misc/tl_PH/__init__.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from ..en_PH import Provider as EnPhMiscProvider
-
-
-class Provider(EnPhMiscProvider):
-    """No difference from Misc Provider for en_PH locale (yet)"""
diff --git a/venv/lib/python3.11/site-packages/faker/providers/misc/tl_PH/__pycache__/__init__.cpython-311.pyc b/venv/lib/python3.11/site-packages/faker/providers/misc/tl_PH/__pycache__/__init__.cpython-311.pyc
deleted file mode 100644
index 15e1d8b..0000000
--- a/venv/lib/python3.11/site-packages/faker/providers/misc/tl_PH/__pycache__/__init__.cpython-311.pyc
+++ /dev/null