3822431117

Build Type

github

Committed by GitHub

Commit Message

Merge c7664efeb into cdd441319

Pull Request Pull Request #54: SQLModel support

Run Details

27 of 27 new or added lines in 4 files covered. (100.0%)

1577 of 1608 relevant lines covered (98.07%)

3.92 hits per line

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

97.67

/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
        if optional:
            meta: DOptional
            if isinstance(meta.type, DList):
                default = "[]"
            elif isinstance(meta.type, DDict):
                default = "{}"
            else:
                default = "None"

        body_kwargs = self._get_field_kwargs(name, meta, optional, data)
        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

    def _get_field_kwargs(self, name: str, meta: MetaData, optional: bool, data: dict):
        body_kwargs = {}
        if name != data["name"]:
            body_kwargs["alias"] = f'"{name}"'
        return body_kwargs

1	from typing import List, Optional, Tuple	4✔
2
3	from .base import GenericModelCodeGenerator, KWAGRS_TEMPLATE, sort_kwargs, template	4✔
4	from ..dynamic_typing import (	4✔
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 = (	4✔
18	"*",
19	)
20
21
22	class PydanticModelCodeGenerator(GenericModelCodeGenerator):	4✔
23	PYDANTIC_FIELD = template("Field({{ default }}{% if kwargs %}, KWAGRS_TEMPLATE{% endif %})"	4✔
24	.replace('KWAGRS_TEMPLATE', KWAGRS_TEMPLATE))
25	default_types_style = {	4✔
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):	4✔
35	"""
36	:param model: ModelMeta instance
37	:param kwargs:
38	"""
39	kwargs['post_init_converters'] = False	4✔
40	super().__init__(model, **kwargs)	4✔
41
42	def generate(self, nested_classes: List[str] = None, extra: str = "", **kwargs) \	4✔
43	-> Tuple[ImportPathList, str]:
44	imports, body = super(PydanticModelCodeGenerator, self).generate(	4✔
45	bases='BaseModel',
46	nested_classes=nested_classes,
47	extra=extra
48	)
49	imports.append(('pydantic', ['BaseModel', 'Field']))	4✔
50	return imports, body	4✔
51
52	def _filter_fields(self, fields):	4✔
53	fields = super()._filter_fields(fields)	4✔
54	filtered = []	4✔
55	for field in fields:	4✔
56	field_type = self.model.type[field]	4✔
57	if field_type in (Unknown, Null):	4✔
58	continue	4✔
59	filtered.append(field)	4✔
60	return filtered	4✔
61
62	def field_data(self, name: str, meta: MetaData, optional: bool) -> Tuple[ImportPathList, dict]:	4✔
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)	4✔
72	default: Optional[str] = None	4✔
73	if optional:	4✔
74	meta: DOptional
75	if isinstance(meta.type, DList):	4✔
76	default = "[]"	4✔
77	elif isinstance(meta.type, DDict):	4✔
78	default = "{}"	×
79	else:
80	default = "None"	4✔
81
82	body_kwargs = self._get_field_kwargs(name, meta, optional, data)	4✔
83	if body_kwargs:	4✔
84	data["body"] = self.PYDANTIC_FIELD.render(	4✔
85	default=default or '...',
86	kwargs=sort_kwargs(body_kwargs, DEFAULT_ORDER)
87	)
88	elif default is not None:	4✔
89	data["body"] = default	4✔
90	return imports, data	4✔
91
92	def _get_field_kwargs(self, name: str, meta: MetaData, optional: bool, data: dict):	4✔
93	body_kwargs = {}	4✔
94	if name != data["name"]:	4✔
95	body_kwargs["alias"] = f'"{name}"'	4✔
96	return body_kwargs	4✔

bogdandm / json2python-models / 3822431117

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