# Source code for dataclass_wizard.wizard_cli.schema

    """
    Generates a Python (dataclass) schema, given a JSON input. The entry point for
    this module is the `gen-schema` subcommand.

    This JSON to Dataclass conversion tool was inspired by the following projects:

        * https://github.com/mischareitsma/json2dataclass
        * https://github.com/russbiggs/json2dataclass
        * https://github.com/mholt/json-to-go

    The parser supports the full JSON spec, so both `list` and `dict` as the
    root type are properly handled as expected.

    A few important notes on the behavior of JSON parsing:

        * Lists with multiple dictionaries will have all the keys and type
          definitions merged into a single model dataclass, as the dictionary
          objects are considered homogenous in this case.

        * Nested lists within the above structure (e.g. list -> dict -> list)
          should similarly merge all list elements with the list for that same key
          in each sibling `dict` object. For example, assuming the below input::
            ... [{"d1": [1, {"k": "v"}]}, {"d1": [{"k": 2}, {"k2": "v2"}, True]}]
          This should result in a single, merged type definition for "d1"::
            ... List[Union[int, dataclass(k: Union[str, int], k2: str), bool]]

        * Any nested dictionaries within lists will have their Model class name
          generated with the singular form of the key containing the model
          definition -- for example, {"Items":[{"key":"value"}]} will result in a
          model class named `Item`. In the case a dictionary is nested within a
          list, it will have the class name auto-incremented with a common
          prefix -- for example, `Data1`, `Data2`, etc.

    The implementation below uses regex code in the `rules.english` module from
    the library Python-Inflector (https://github.com/bermi/Python-Inflector).

    This library is available under the BSD license, which can be
    obtained from https://opensource.org/licenses.

    The library Python-Inflector contains the following attribution notices:

        Copyright (c) 2006 Bermi Ferrer Martinez
        bermi a-t bermilabs - com

    See the end of this file for the original BSD-style license from this library.

    """

    __all__ = [
        'PyCodeGenerator'
    ]

    import json
    import re
    import textwrap
    from collections import defaultdict
    from collections import deque
    from collections.abc import Iterable
    from dataclasses import dataclass, field, InitVar
    from datetime import date, datetime, time
    from enum import Enum
    from pathlib import Path
    from typing import Callable, Any, Optional, TypeVar, Type, ClassVar
    from typing import DefaultDict, Set, List
    from typing import (
        Union, Dict, Sequence
    )

    from .. import property_wizard
    from ..constants import PACKAGE_NAME
    from ..class_helper import get_class_name
    from ..type_def import PyDeque, JSONList, JSONObject, JSONValue, T
    from ..utils.string_conv import to_snake_case, to_pascal_case
    # noinspection PyProtectedMember
    from ..utils.type_conv import TRUTHY_VALUES
    from ..utils.type_conv import as_datetime, as_date, as_time

    # Some unconstrained type variables.  These are used by the container types.
    # (These are not for export.)
    _S = TypeVar('_S')

    # Merge both the "truthy" and "falsy" values, so we can determine the criteria
    # under which a string can be considered as a boolean value.
    _FALSY_VALUES = {'false', 'f', 'no', 'n', 'off', '0'}
    _BOOL_VALUES = TRUTHY_VALUES | _FALSY_VALUES

    # Valid types for JSON contents; this can be either a list of any type,
    # or a dictionary with `string` keys and values of any type.
    JSONBlobType = Union[JSONList, JSONObject]

    PyDataTypeOrSeq = Union['PyDataType', Sequence['PyDataType']]
    TypeContainerElements = Union[PyDataTypeOrSeq,
                                  'PyDataclassGenerator', 'PyListGenerator']

    @dataclass
    class PyCodeGenerator:
        """
        This is the main class responsible for generating Python code that
        leverages dataclasses, given a JSON object as an input data.
        """

        # Either the file name (ex. file1.json) or the file contents as a string
        # can be passed in as an input to the constructor method.
        file_name: InitVar[str] = None
        file_contents: InitVar[str] = None

        # Should we force-resolve inferred types for strings? For example, a value
        # of "TRUE" will appear as a `Union[str, bool]` type by default.
        force_strings: InitVar[bool] = None

        # Enable experimental features via a `__future__` import, which allows
        # PEP-585 and PEP-604 style annotations in Python 3.7+
        experimental: InitVar[bool] = None

        # The rest of these fields are just for internal use.
        parser: 'JSONRootParser' = field(init=False)
        data: JSONBlobType = field(init=False)
        _py_code_lines: List[str] = field(default=None, init=False)

        def __post_init__(self, file_name: str, file_contents: str,
                          force_strings: bool, experimental: bool):

            # Set global flags
            global Globals
            Globals = _Globals(force_strings=force_strings,
                               experimental=experimental)

            # https://stackoverflow.com/a/62940588/10237506
            if file_name:
                file_path = Path(file_name)
                file_contents = file_path.read_bytes()

            self.data = json.loads(file_contents)
            self.parser = JSONRootParser(self.data)

        @property
        def py_code(self) -> str:

            if self._py_code_lines is None:
                # Generate Python code for the dataclass(es)
                dataclass_code: str = repr(self.parser)
                # Add any imports used at the top of the code
                self._py_code_lines = ModuleImporter.imports
                if self._py_code_lines:
                    self._py_code_lines.append('')
                # Generate final Python code - imports + dataclass(es)
                self._py_code_lines.append(dataclass_code)

            return '\n'.join(self._py_code_lines)

    # Global flags (generally passed in via command-line) which are shared by
    # classes and functions.
    Globals: '_Globals | None' = None

    @dataclass
    class _Globals:

        # Should we force-resolve inferred types for strings? For example, a value
        # of "TRUE" will appear as a `Union[str, bool]` type by default.
        force_strings: bool = False

        # Enable experimental features via a `__future__` import, which allows
        # PEP-585 and PEP-604 style annotations in Python 3.7+
        experimental: bool = False

        # Should we insert auto-generated comments under each dataclass.
        insert_comments: bool = True

        # Should we include a newline after the comments block mentioned above.
        newline_after_class_def: bool = True

    # Credits: https://github.com/bermi/Python-Inflector
    class English:
        """
        Inflector for pluralize and singularize English nouns.

        This is the default Inflector for the Inflector obj
        """

        @staticmethod
        def humanize(word):
            """
            Returns a human-readable string from word, by replacing
            underscores with a space, and by upper-casing the initial
            character by default.
            """
            return to_snake_case(word).replace('_', ' ').title()

        @staticmethod
        def singularize(word):
            """Singularizes English nouns."""

            rules = [
                ['(?i)(quiz)zes$', '\\1'],
                ['(?i)(matr)ices$', '\\1ix'],
                ['(?i)(vert|ind)ices$', '\\1ex'],
                ['(?i)^(ox)en', '\\1'],
                ['(?i)(alias|status)es$', '\\1'],
                ['(?i)([octop|vir])i$', '\\1us'],
                ['(?i)(cris|ax|test)es$', '\\1is'],
                ['(?i)(shoe)s$', '\\1'],
                ['(?i)(o)es$', '\\1'],
                ['(?i)(bus)es$', '\\1'],
                ['(?i)([m|l])ice$', '\\1ouse'],
                ['(?i)(x|ch|ss|sh)es$', '\\1'],
                ['(?i)(m)ovies$', '\\1ovie'],
                ['(?i)(s)eries$', '\\1eries'],
                ['(?i)([^aeiouy]|qu)ies$', '\\1y'],
                ['(?i)([lr])ves$', '\\1f'],
                ['(?i)(tive)s$', '\\1'],
                ['(?i)(hive)s$', '\\1'],
                ['(?i)([^f])ves$', '\\1fe'],
                ['(?i)(^analy)ses$', '\\1sis'],
                ['(?i)(^analysis)$', '\\1'],
                ['(?i)((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$', '\\1\\2sis'],
                # I don't want 'Data' replaced with 'Datum', however
                ['(?i)(^data)$', '\\1'],
                ['(?i)([ti])a$', '\\1um'],
                ['(?i)(n)ews$', '\\1ews'],
                ['(?i)s$', ''],
            ]

            uncountable_words = ['equipment', 'information', 'rice', 'money',
                                 'species', 'series', 'fish', 'sheep', 'sms']

            irregular_words = {
                'people': 'person',
                'men': 'man',
                'children': 'child',
                'sexes': 'sex',
                'moves': 'move'
            }

            lower_cased_word = word.lower()

            for uncountable_word in uncountable_words:
                if lower_cased_word[-1 * len(uncountable_word):] == uncountable_word:
                    return word

            for irregular in irregular_words.keys():
                match = re.search('(' + irregular + ')$', word, re.IGNORECASE)
                if match:
                    return re.sub(
                        '(?i)' + irregular + '$',
                        match.expand('\\1')[0] + irregular_words[irregular][1:],
                        word)

            for rule in range(len(rules)):
                match = re.search(rules[rule][0], word, re.IGNORECASE)
                if match:
                    groups = match.groups()
                    for k in range(0, len(groups)):
                        if groups[k] == None:
                            rules[rule][1] = rules[
                                rule][1].replace('\\' + str(k + 1), '')

                    return re.sub(rules[rule][0], rules[rule][1], word)

            return word

    # noinspection SpellCheckingInspection, PyPep8Naming
    class classproperty:
        """
        Decorator that converts a method with a single cls argument into a
        property that can be accessed directly from the class.

        Credits:
            - https://stackoverflow.com/a/57055258/10237506
            - https://docs.djangoproject.com/en/3.1/ref/utils/#django.utils.functional.classproperty

        """
        def __init__(self, method: Callable[[Any], T]) -> None:
            self.f = method

        def __get__(
                self, instance: Optional[_S], cls: Optional[Type[_S]] = None) -> T:
            return self.f(cls)

        def getter(self, method):
            self.f = method
            return self

    def is_float(s: str) -> bool:
        """
        Check if a string is a :class:`float` value
          ex. '1.23'
        """
        try:
            _ = float(s)
            return True
        except ValueError:
            return False

    def can_be_bool(o: str) -> bool:
        """
        Check if a string can be a :class:`bool` value. Note this doesn't mean
        that the string can or should be converted to bool, only that it *appears*
        to be one.

        """
        return o.lower() in _BOOL_VALUES

    class PyDataType(Enum):
        """
        Enum representing a Python Data Type
        """
        STRING = str
        FLOAT = float
        INT = int
        BOOL = bool
        LIST = list
        DICT = dict
        DATE = date
        DATETIME = datetime
        TIME = time
        NULL = None

        def __str__(self) -> str:
            """
            Returns the string representation of an Enum member's value.
            """
            return getattr(
                self.value, '__name__', str(self.value))

    class ModuleImporter:
        """
        Helper class responsible for constructing import statements in the
        generated Python code.
        """

        # Import level (e.g. stdlib or 3rd party) -> Module Name -> Module Imports
        _MOD_IMPORTS: DefaultDict[int, DefaultDict[str, Set[str]]] = defaultdict(
            lambda: defaultdict(set)
        )

        # noinspection PyMethodParameters
        @classproperty
        def imports(cls: Type[T]) -> List[str]:
            """
            Returns a list of generated import statements based on the modules
            currently used in the code.
            """

            lines = []

            for lvl in sorted(cls._MOD_IMPORTS):
                modules = cls._MOD_IMPORTS[lvl]
                for mod in sorted(modules):
                    imported = sorted(modules[mod])
                    lines.append(f'from {mod} import {", ".join(imported)}')
                lines.append('')

            return lines

        @classmethod
        def wrap_string_with_import(cls, string: str,
                                    imported: object,
                                    wrap_chars='[]',
                                    register_import=True,
                                    level=1) -> str:
            """
            Wraps `string` so it is contained within `imported`. The `wrap_chars`
            parameter determines the enclosing characters to use -- defaults to
            braces by default, as subscripted type Generics often appear in this
            form.

            If `register_import` is true (default), an import statement will also
            be generated for the `imported` usage, if one needs to be added.

            Examples::

                >>> ModuleImporter.wrap_string_with_import('int', List)
                'List[int]'

            """

            module = imported.__module__
            name = cls._get_import_name(imported)
            start, end = wrap_chars

            if register_import:
                cls.register_import_by_name(module, name, level)

            return f'{name}{start}{string}{end}'

        # noinspection PyUnresolvedReferences
        @classmethod
        def wrap_with_import(cls, deck: PyDeque[str],
                             imported: object,
                             wrap_chars='[]',
                             register_import=True,
                             level=1) -> None:
            """
            Same as :meth:`wrap_string_with_import` above, except this accepts
            a list (deque) of strings to be wrapped instead.
            """

            module = imported.__module__
            name = cls._get_import_name(imported)
            start, end = wrap_chars

            if register_import:
                cls.register_import_by_name(module, name, level)

            deck.appendleft(start)
            deck.appendleft(name)
            deck.append(end)

        @classmethod
        def register_import(cls, imported: object, level=1) -> None:
            """
            Registers a new import for the given object.

            Examples::

                >>> ModuleImporter.register_import(datetime)

            """

            module = imported.__module__
            name = cls._get_import_name(imported)

            cls.register_import_by_name(module, name, level)

        @classmethod
        def register_import_by_name(cls, module: str, name: str, level: int) -> None:
            """
            Registers a new import for a module and the imported name.

            Note: any built-in's like "int" or "min" should be skipped by
            default.
            """

            # Skip any built-in helper functions
            #   if name in __builtins__.__dict__:
            if module == 'builtins':
                return

            cls._MOD_IMPORTS[level][module].add(name)

        @classmethod
        def register_future_import(cls, name: str) -> None:
            """
            Registers a top-level `__future__` import for a module, which is
            required to be the first import defined at the top of the file.

            """
            cls._MOD_IMPORTS[0]['__future__'].add(name)

        @classmethod
        def clear_imports(cls):
            """
            Clears all the module imports currently in the cache.
            """

            cls._MOD_IMPORTS.clear()

        @classmethod
        def _get_import_name(cls, imported: Any) -> str:
            """Retrieves the name of an imported object."""
            return cls._safe_get_class_name(imported)

        @staticmethod
        def _safe_get_class_name(cls: Any):
            """
            Retrieves the class name of the specified object or class.

            Note: the `_name` attribute is specific to most Generic types in
            the `typing` module.
            """

            try:
                return cls._name

            except AttributeError:
                # Useful to strip underscores from the start, for example
                # in Python 3.6 which doesn't have a `_name` attribute for the
                # `Union` type, and the class name is returned as `_Union`.
                return get_class_name(cls).lstrip('_')

    @dataclass(repr=False)
    class TypeContainer(List[TypeContainerElements]):
        """
        Custom list class which functions as a container for Python data types.
        """

        # This keeps track of whether we've seen a `null` type before.
        is_optional = False

        def append(self, o: TypeContainerElements):
            """
            Appends an object (or a sequence of objects) to the
            :class:`TypeContainer` instance.
            """

            if isinstance(o, Iterable):
                for elem in o:
                    self.append(elem)
                return

            if o is PyDataType.NULL:
                self.is_optional = True
                return

            if o in self:
                return

            if isinstance(o, PyDataType):
                # Register the types in case they are not standard imports.
                # For example, `uuid` and `datetime` objects.
                ModuleImporter.register_import(o.value)

            super(TypeContainer, self).append(o)

        def __or__(self, other):
            """
            Performs logical OR, to merge instances of :class:`TypeContainer`
            """

            if not isinstance(other, TypeContainer):
                raise TypeError(
                    f'TypeContainer: incorrect type for __add__: {type(other)}')

            # Remember to carry over the `is_optional` flag
            self.is_optional |= other.is_optional

            if len(self) == 1 and len(other) == 1:
                self_item = self[0]
                other_item = other[0]

                for typ in PyDataclassGenerator, PyListGenerator:
                    if isinstance(self_item, typ) and isinstance(other_item, typ):
                        # We call  `__or__` to merge the lists or dataclasses
                        # together.
                        self_item |= other_item

                        return self

            for elem in other:
                self.append(elem)

            return self

        def __repr__(self):
            """
            Iteratively calls the `repr` method of all our model collection types.
            """

            lines = []

            for typ in self:
                if isinstance(typ, (PyDataclassGenerator, PyListGenerator)):
                    lines.append(repr(typ))

            return '\n'.join(lines)

        def __str__(self):
            ...

        def _default_str(self):
            """
            Return the string representation of the resolved type -
              ex.`Optional[Union[str, int]]`

            """

            # I'm using `deque`s here to avoid doing `list.insert(0, x)` or later
            # iterating over `reversed(list)`, as this might be a bit faster.
            # noinspection PyUnresolvedReferences
            typing_imports: PyDeque[object] = deque()
            # noinspection PyUnresolvedReferences
            parts: PyDeque[str]

            if not self:
                # This is the case when the only value encountered for a field is
                # a `null` - hence, we're unable to determine the type.
                typing_imports.appendleft(Any)

            elif self.is_optional:
                typing_imports.appendleft(Optional)

            if len(self) > 1:
                # Else, if we have more than one type for a field, then the
                # resolved type should be a `Union` of all the seen types.
                typing_imports.appendleft(Union)

            parts = deque(', '.join(str(typ) for typ in self))

            for tp in typing_imports:
                ModuleImporter.wrap_with_import(parts, tp)

            return ''.join(parts).replace('[]', '')

        def _experimental_features_str(self):

            if not self:
                # This is the case when the only value encountered for a field is
                # a `null` - hence, we're unable to determine the type.
                ModuleImporter.register_import(Any)
                return 'Any'

            parts = [str(typ) for typ in self]
            if self.is_optional:
                parts.append('None')

            return ' | '.join(parts)

    def possible_types_for_string_value(string: str) -> PyDataTypeOrSeq:
        """
        Returns possible types for a JSON field with a :class:`string` value,
        depending on what that value appears to be.

        If `Globals.force_strings` is true and there is more than one possible
        type, we simply return the inferred type, instead of the
        `Union[T..., str]` syntax.
        """

        exc_types = TypeError, ValueError

        try:
            _ = as_date(string)
            return PyDataType.DATE
        except exc_types:
            pass

        # I want to eliminate false positives so this seems the easiest
        # way to do that. Otherwise strings like "24" seem to get parsed
        # as a :class:`Time` object, which might not be expected.
        if ':' not in string:
            possible_types = []

            if string.isnumeric():
                possible_types.append(PyDataType.INT)

            elif is_float(string):
                possible_types.append(PyDataType.FLOAT)

            elif can_be_bool(string):
                possible_types.append(PyDataType.BOOL)

            # If force-resolve is enabled, just return the inferred type if one
            # was determined.
            # noinspection PyUnresolvedReferences
            if Globals.force_strings and possible_types:
                return possible_types[0]

            possible_types.append(PyDataType.STRING)

            return possible_types

        try:
            _ = as_time(string)
            return PyDataType.TIME
        except exc_types:
            pass

        try:
            _ = as_datetime(string)
            return PyDataType.DATETIME
        except exc_types:
            pass

        return PyDataType.STRING

    def json_to_python_type(o: JSONValue) -> PyDataTypeOrSeq:
        """
        Convert a JSON object to a Python Data Type, or a Union of Python Data
        Types.
        """

        if o is None:
            return PyDataType.NULL

        if isinstance(o, str):
            return possible_types_for_string_value(o)

        # `bool` needs to come before `int`, as it's a subclass of `int`
        if isinstance(o, bool):
            return PyDataType.BOOL

        if isinstance(o, int):
            return PyDataType.INT

        if isinstance(o, float):
            return PyDataType.FLOAT

        if isinstance(o, list):
            return PyDataType.LIST

        if isinstance(o, dict):
            return PyDataType.DICT

    @dataclass
    class JSONRootParser:

        data: JSONBlobType

        model: Union['PyListGenerator',
                     'PyDataclassGenerator'] = field(init=False)

        def __post_init__(self):

            # Clear imports from last run
            ModuleImporter.clear_imports()

            str_method_prefix = 'default'

            # Check if experimental features are enabled
            if Globals.experimental:
                # Add the required `__future__` import
                ModuleImporter.register_future_import('annotations')
                # Update how annotations are resolved
                str_method_prefix = 'experimental_features'

            # Set the `__str__` method to use for classes
            str_method_name = f'_{str_method_prefix}_str'
            for typ in TypeContainer, PyListGenerator, PyDataclassGenerator:
                typ.__str__ = getattr(typ, str_method_name)

            # We'll need an import for the @dataclass decorator, at a minimum
            ModuleImporter.register_import(dataclass)

            if isinstance(self.data, list):
                self.model = PyListGenerator(self.data,
                                             is_root=True)

            elif isinstance(self.data, dict):
                self.model = PyDataclassGenerator(self.data,
                                                  is_root=True)

            else:
                raise TypeError(
                    'Incorrect type, expected a JSON `list` or `dict`. '
                    f'actual_type={type(self.data)!r}, data={self.data!r}')

        def __repr__(self):
            return repr(self.model) + '\n'

    @dataclass
    class PyDataclassGenerator(metaclass=property_wizard):

        data: InitVar[JSONObject]

        _name: str = 'data'
        indent: str = ' ' * 4
        is_root: bool = False

        nested_lvl: InitVar[int] = 0

        parsed_types: DefaultDict[str, TypeContainer] = field(
            init=False,
            default_factory=lambda: defaultdict(TypeContainer)
        )

        @property
        def name(self):
            return self._name

        @name.setter
        def name(self, name: str):
            """Title case the name"""
            self._name = to_pascal_case(name)

        @classmethod
        def load_parsed(
                cls: Type[T],
                parsed_types: Dict[str,
                                   Union[PyDataType, 'PyDataclassGenerator']],
                **constructor_kwargs
        ) -> T:

            obj = cls({}, **constructor_kwargs)

            for k, typ in parsed_types.items():
                underscored_field = to_snake_case(k)
                obj.parsed_types[underscored_field].append(typ)

            return obj

        def __post_init__(self, data: JSONObject, nested_lvl: int):

            for k, v in data.items():
                underscored_field = to_snake_case(k)
                typ = json_to_python_type(v)

                if typ is PyDataType.DICT:
                    typ = PyDataclassGenerator(
                        v, k,
                        nested_lvl=nested_lvl,
                    )
                elif typ is PyDataType.LIST:
                    nested_lvl += 1
                    typ = PyListGenerator(
                        v, k, k,
                        nested_lvl=nested_lvl,
                    )

                self.parsed_types[underscored_field].append(typ)

        def __or__(self, other):
            if not isinstance(other, PyDataclassGenerator):
                raise TypeError(
                    f'{self.__class__.__name__}: Incorrect type for `__or__`. '
                    f'actual_type: {type(other)}, object={other}')

            for k, v in other.parsed_types.items():
                if k in self.parsed_types:
                    self.parsed_types[k] |= v

                else:
                    self.parsed_types[k] = v

            return self

        def get_lines(self) -> List[str]:
            if self.is_root:
                ModuleImporter.register_import_by_name(
                    PACKAGE_NAME, 'JSONWizard', level=2)
                class_name = f'class {self.name}(JSONWizard):'
            else:
                class_name = f'class {self.name}:'

            class_parts = ['@dataclass',
                           class_name]
            parts = []
            nested_parts = []

            # noinspection PyUnresolvedReferences
            if Globals.insert_comments:
                class_parts.append(
                    textwrap.indent('"""', self.indent))
                class_parts.append(
                    textwrap.indent(f'{self.name} dataclass', self.indent))

                # noinspection PyUnresolvedReferences
                if Globals.newline_after_class_def:
                    class_parts.append('')

                class_parts.append(textwrap.indent(
                    '"""', self.indent))

            for k, v in self.parsed_types.items():
                line = f'{k}: {v}'
                wrapped_line = textwrap.indent(line, self.indent)
                parts.append(wrapped_line)

                nested_part = repr(v)
                if nested_part:
                    nested_parts.append(nested_part)

            for part in nested_parts:
                parts.append('\n')
                parts.append(part)

            if not parts:
                parts = [textwrap.indent('pass', self.indent)]

            class_parts.extend(parts)

            return class_parts

        def __str__(self):
            ...

        def _default_str(self):
            return f"'{self.name}'"

        def _experimental_features_str(self):
            return self.name

        def __repr__(self):
            """
            Returns the Python `dataclasses` representation of the object.
            """
            return '\n'.join(self.get_lines())

    @dataclass(repr=False)
    class PyListGenerator(metaclass=property_wizard):
        """
        Parse a list in a JSON object to a Python list, based on the following
        rules:

        * If the JSON list contains *only* simple types, for example int,
          str, or bool, then invoking ``str()`` on this object should return
          a Union representation of those types, for example
          `Union[int, str, bool]`.

        * If the JSON list contains *any* complex type, like a dict, then
          all `dict`s should have their keys and values merged together.
          Optional and Union should be included if needed.

          Additionally, if `is_root` is true, then calling ``str()`` will
          effectively ignore any simple types,

        """

        # Default name for model class if none is provided.
        default_name: ClassVar[str] = 'data'

        data: JSONList

        container_name: str = 'container'
        _name: str = None

        indent: str = ' ' * 4

        is_root: InitVar[bool] = False
        nested_lvl: InitVar[int] = 0

        root: PyDataclassGenerator = field(init=False, default=None)

        parsed_types: TypeContainer = field(init=False,
                                            default_factory=TypeContainer)

        # Model is our model dataclass object, which may or may not be present
        # in the list. If there are multiple models (i.e. dicts), their keys
        # and the associated type defs should be merged into one model.
        model: PyDataclassGenerator = field(init=False, default=None)

        @property
        def name(self):
            return self._name

        @name.setter
        def name(self, name: Optional[str]):
            """Title case and singularize the name."""
            if name:
                name = English.humanize(name)
                name = English.singularize(name).replace(' ', '')

            self._name = name

        def __post_init__(self, is_root: bool, nested_lvl: int):

            if not self.name:
                # Increment the suffix if needed
                if nested_lvl:
                    self.name = f'{self.default_name}{nested_lvl}'
                else:
                    self.name = self.default_name

            # Temp data dictionary object
            data_list = []

            for elem in self.data:

                typ = json_to_python_type(elem)

                if typ is PyDataType.DICT:

                    typ = PyDataclassGenerator(elem, self.name,
                                               nested_lvl=nested_lvl,
                                               is_root=is_root)

                    if self.model:
                        self.model |= typ
                        continue

                    self.model = typ

                else:
                    # Nested lists.
                    if typ is PyDataType.LIST:
                        nested_lvl += 1
                        typ = PyListGenerator(elem, nested_lvl=nested_lvl)

                    data_list.append(typ)

                self.parsed_types.append(typ)

            if is_root:

                # We want to start off by adding the nested `dataclass` field
                # first, so it shows up at the top of the container `dataclass`.
                data_dict = {self.name: self.model} if self.model else {}

                data_dict.update({
                    f'field_{i + 1}': elem
                    for i, elem in enumerate(data_list)
                })

                self.root = PyDataclassGenerator.load_parsed(
                    data_dict,
                    nested_lvl=nested_lvl
                )
                self.root.name = self.container_name

        def __or__(self, other):
            """Merge two lists together."""
            if not isinstance(other, PyListGenerator):
                raise TypeError(
                    f'{self.__class__.__name__}: Incorrect type for `__or__`. '
                    f'actual_type: {type(other)}, object={other}')

            # To merge lists with equal number of elements, that's easy enough:
            #   [{"key": "v1"}] | [{"key2": 2}] = [{"key": "v1", "key2": 2}]
            #
            # But... what happens when it's something like this?
            #   [1, {"key": "v1"}] | [{"key2": "2}, "testing", 1, 2, 3]
            #
            # Solution is to merge the model in the other list class with our
            # model -- note that both ours and the other instance end up with only
            # one model after `__post_init__` runs. However, easiest way is to
            # iterate over the nested types in the other list and check for the
            # model explicitly. For the rest of the types in the other list
            # (including nested lists), we just add them to our current list.
            for t in other.parsed_types:
                if isinstance(t, PyDataclassGenerator):
                    if self.model:
                        self.model |= t
                        continue
                    self.model = t
                self.parsed_types.append(t)

            return self

        def get_lines(self) -> List[str]:

            lines = []

            if self.root:
                lines.append(repr(self.root))

            else:
                if self.model:
                    lines.append(repr(self.model))

                for t in self.parsed_types:
                    if isinstance(t, PyListGenerator):
                        code = repr(t)
                        if code:
                            # Only if our list already has a dataclass, append
                            # a newline. This should add the proper number of
                            # spaces, in a case like below.
                            #   [{"another_Key":  "value"}, [{"key":  "value"}]]
                            if self.model:
                                lines.append('\n')
                            lines.append(code)

            return lines

        def __str__(self):
            ...

        def _default_str(self):

            if len(self.parsed_types) == 0:
                # We could also wrap it with 'Optional' here, since we see it's
                # an empty list, but it's probably better to not not do that, as
                # 'Optional' generally means the value can be an explicit "null".
                #
                # return ModuleImporter.wrap_string_with_import('list', Optional)
                return ModuleImporter.wrap_string_with_import('', List)

            return ModuleImporter.wrap_string_with_import(
                str(self.parsed_types), List)

        def _experimental_features_str(self):

            if len(self.parsed_types) == 0:
                return 'list'

            return ModuleImporter.wrap_string_with_import(
                str(self.parsed_types), list)

        def __repr__(self):
            """
            Returns the Python `dataclasses` representation of the object.
            """
            return '\n'.join(self.get_lines())

    if __name__ == '__main__':
        loader = PyCodeGenerator('../../tests/testdata/test1.json')
        print(loader.py_code)

    # Copyright (c) 2006 Bermi Ferrer Martinez
    # Permission is hereby granted, free of charge, to any person obtaining a copy
    # of this software to deal in this software without restriction, including
    # without limitation the rights to use, copy, modify, merge, publish,
    # distribute, sublicense, and/or sell copies of this software, and to permit
    # persons to whom this software is furnished to do so, subject to the following
    # condition:
    #
    # THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    # OUT OF OR IN CONNECTION WITH THIS SOFTWARE OR THE USE OR OTHER DEALINGS IN
    # THIS SOFTWARE.