3822451468

Build Type

github

Committed by GitHub

Commit Message

Merge 8c3a0adb5 into cdd441319

Pull Request Pull Request #55: Add python3.11 to test matrix

Run Details

1553 of 1584 relevant lines covered (98.04%)

4.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.5

/json_to_models/models/pydantic.py

from typing import List, Optional, Tuple

from .base import GenericModelCodeGenerator, KWAGRS_TEMPLATE, sort_kwargs, template
from ..dynamic_typing import (
    DDict,
    DList,
    DOptional,
    ImportPathList,
    MetaData,
    ModelMeta,
    Null,
    StringLiteral,
    StringSerializable,
    Unknown
)

DEFAULT_ORDER = (
    "*",
)


class PydanticModelCodeGenerator(GenericModelCodeGenerator):
    PYDANTIC_FIELD = template("Field({{ default }}{% if kwargs %}, KWAGRS_TEMPLATE{% endif %})"
                              .replace('KWAGRS_TEMPLATE', KWAGRS_TEMPLATE))
    default_types_style = {
        StringSerializable: {
            StringSerializable.TypeStyle.use_actual_type: True
        },
        StringLiteral: {
            StringLiteral.TypeStyle.use_literals: True
        }
    }

    def __init__(self, model: ModelMeta, **kwargs):
        """
        :param model: ModelMeta instance
        :param kwargs:
        """
        kwargs['post_init_converters'] = False
        super().__init__(model, **kwargs)

    def generate(self, nested_classes: List[str] = None, extra: str = "", **kwargs) \
            -> Tuple[ImportPathList, str]:
        imports, body = super(PydanticModelCodeGenerator, self).generate(
            bases='BaseModel',
            nested_classes=nested_classes,
            extra=extra
        )
        imports.append(('pydantic', ['BaseModel', 'Field']))
        return imports, body

    def _filter_fields(self, fields):
        fields = super()._filter_fields(fields)
        filtered = []
        for field in fields:
            field_type = self.model.type[field]
            if field_type in (Unknown, Null):
                continue
            filtered.append(field)
        return filtered

    def field_data(self, name: str, meta: MetaData, optional: bool) -> Tuple[ImportPathList, dict]:
        """
        Form field data for template

        :param name: Original field name
        :param meta: Field metadata
        :param optional: Is field optional
        :return: imports, field data
        """
        imports, data = super().field_data(name, meta, optional)
        default: Optional[str] = None
        body_kwargs = {}
        if optional:
            meta: DOptional
            if isinstance(meta.type, DList):
                default = "[]"
            elif isinstance(meta.type, DDict):
                default = "{}"
            else:
                default = "None"

        if name != data["name"]:
            body_kwargs["alias"] = f'"{name}"'
        if body_kwargs:
            data["body"] = self.PYDANTIC_FIELD.render(
                default=default or '...',
                kwargs=sort_kwargs(body_kwargs, DEFAULT_ORDER)
            )
        elif default is not None:
            data["body"] = default
        return imports, data

1	from typing import List, Optional, Tuple	5✔
2
3	from .base import GenericModelCodeGenerator, KWAGRS_TEMPLATE, sort_kwargs, template	5✔
4	from ..dynamic_typing import (	5✔
5	DDict,
6	DList,
7	DOptional,
8	ImportPathList,
9	MetaData,
10	ModelMeta,
11	Null,
12	StringLiteral,
13	StringSerializable,
14	Unknown
15	)
16
17	DEFAULT_ORDER = (	5✔
18	"*",
19	)
20
21
22	class PydanticModelCodeGenerator(GenericModelCodeGenerator):	5✔
23	PYDANTIC_FIELD = template("Field({{ default }}{% if kwargs %}, KWAGRS_TEMPLATE{% endif %})"	5✔
24	.replace('KWAGRS_TEMPLATE', KWAGRS_TEMPLATE))
25	default_types_style = {	5✔
26	StringSerializable: {
27	StringSerializable.TypeStyle.use_actual_type: True
28	},
29	StringLiteral: {
30	StringLiteral.TypeStyle.use_literals: True
31	}
32	}
33
34	def __init__(self, model: ModelMeta, **kwargs):	5✔
35	"""
36	:param model: ModelMeta instance
37	:param kwargs:
38	"""
39	kwargs['post_init_converters'] = False	5✔
40	super().__init__(model, **kwargs)	5✔
41
42	def generate(self, nested_classes: List[str] = None, extra: str = "", **kwargs) \	5✔
43	-> Tuple[ImportPathList, str]:
44	imports, body = super(PydanticModelCodeGenerator, self).generate(	5✔
45	bases='BaseModel',
46	nested_classes=nested_classes,
47	extra=extra
48	)
49	imports.append(('pydantic', ['BaseModel', 'Field']))	5✔
50	return imports, body	5✔
51
52	def _filter_fields(self, fields):	5✔
53	fields = super()._filter_fields(fields)	5✔
54	filtered = []	5✔
55	for field in fields:	5✔
56	field_type = self.model.type[field]	5✔
57	if field_type in (Unknown, Null):	5✔
58	continue	5✔
59	filtered.append(field)	5✔
60	return filtered	5✔
61
62	def field_data(self, name: str, meta: MetaData, optional: bool) -> Tuple[ImportPathList, dict]:	5✔
63	"""
64	Form field data for template
65
66	:param name: Original field name
67	:param meta: Field metadata
68	:param optional: Is field optional
69	:return: imports, field data
70	"""
71	imports, data = super().field_data(name, meta, optional)	5✔
72	default: Optional[str] = None	5✔
73	body_kwargs = {}	5✔
74	if optional:	5✔
75	meta: DOptional
76	if isinstance(meta.type, DList):	5✔
77	default = "[]"	5✔
78	elif isinstance(meta.type, DDict):	5✔
79	default = "{}"	×
80	else:
81	default = "None"	5✔
82
83	if name != data["name"]:	5✔
84	body_kwargs["alias"] = f'"{name}"'	5✔
85	if body_kwargs:	5✔
86	data["body"] = self.PYDANTIC_FIELD.render(	5✔
87	default=default or '...',
88	kwargs=sort_kwargs(body_kwargs, DEFAULT_ORDER)
89	)
90	elif default is not None:	5✔
91	data["body"] = default	5✔
92	return imports, data	5✔

bogdandm / json2python-models / 3822451468

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous