def test_sort_data_models_unresolved_raise_recursion_error():
reference = [
BaseModel(name='A', reference_classes=['A', 'C'], fields=[]),
BaseModel(name='B', reference_classes=['B'], fields=[]),
BaseModel(name='C', reference_classes=['B'], fields=[]),
BaseModel(name='D', reference_classes=['A', 'C', 'v'], fields=[]),
BaseModel(name='z', reference_classes=['v'], fields=[]),
]
with pytest.raises(Exception):
sort_data_models(reference, recursion_count=100000)
def test_sort_data_models_unresolved():
reference = [
BaseModel(name='A', reference_classes=['A', 'C'], fields=[]),
BaseModel(name='B', reference_classes=['B'], fields=[]),
BaseModel(name='C', reference_classes=['B'], fields=[]),
BaseModel(name='D', reference_classes=['A', 'C', 'v'], fields=[]),
BaseModel(name='z', reference_classes=['v'], fields=[]),
]
with pytest.raises(Exception):
sort_data_models(reference)
def test_sort_data_models():
reference_a = Reference(path='A', original_name='A', name='A')
reference_b = Reference(path='B', original_name='B', name='B')
reference_c = Reference(path='C', original_name='C', name='C')
data_type_a = DataType(reference=reference_a)
data_type_b = DataType(reference=reference_b)
data_type_c = DataType(reference=reference_c)
reference = [
BaseModel(
fields=[
DataModelField(data_type=data_type_a),
DataModelFieldBase(data_type=data_type_c),
],
reference=reference_a,
),
BaseModel(
fields=[DataModelField(data_type=data_type_b)],
reference=reference_b,
),
BaseModel(
fields=[DataModelField(data_type=data_type_b)],
reference=reference_c,
),
]
unresolved, resolved, require_update_action_models = sort_data_models(
reference)
expected = OrderedDict()
expected['B'] = reference[1]
expected['C'] = reference[2]
expected['A'] = reference[0]
assert resolved == expected
assert unresolved == []
assert require_update_action_models == ['B', 'A']
def parse(self,
with_import: Optional[bool] = True,
format_: Optional[bool] = True) -> str:
for obj_name, raw_obj in self.base_parser.specification['components'][
'schemas'].items(): # type: str, Dict
obj = JsonSchemaObject.parse_obj(raw_obj)
if obj.is_object:
self.parse_object(obj_name, obj)
elif obj.is_array:
self.parse_array(obj_name, obj)
elif obj.enum:
self.parse_enum(obj_name, obj)
elif obj.allOf:
self.parse_all_of(obj_name, obj)
else:
self.parse_root_type(obj_name, obj)
result: str = ''
if with_import:
if self.target_python_version == PythonVersion.PY_37:
self.imports.append(IMPORT_ANNOTATIONS)
result += f'{self.imports.dump()}\n\n\n'
_, sorted_data_models, require_update_action_models = sort_data_models(
self.results)
result += dump_templates(list(sorted_data_models.values()))
if self.dump_resolve_reference_action:
result += f'\n\n{self.dump_resolve_reference_action(require_update_action_models)}'
if format_:
result = format_code(result, self.target_python_version)
return result
def test_sort_data_models_unresolved():
reference_a = Reference(path='A', original_name='A', name='A')
reference_b = Reference(path='B', original_name='B', name='B')
reference_c = Reference(path='C', original_name='C', name='C')
reference_d = Reference(path='D', original_name='D', name='D')
reference_v = Reference(path='V', original_name='V', name='V')
reference_z = Reference(path='Z', original_name='Z', name='Z')
data_type_a = DataType(reference=reference_a)
data_type_b = DataType(reference=reference_b)
data_type_c = DataType(reference=reference_c)
data_type_v = DataType(reference=reference_v)
data_type_z = DataType(reference=reference_z)
reference = [
BaseModel(
fields=[
DataModelField(data_type=data_type_a),
DataModelFieldBase(data_type=data_type_c),
],
reference=reference_a,
),
BaseModel(
fields=[DataModelField(data_type=data_type_b)],
reference=reference_b,
),
BaseModel(
fields=[DataModelField(data_type=data_type_b)],
reference=reference_c,
),
BaseModel(
fields=[
DataModelField(data_type=data_type_a),
DataModelField(data_type=data_type_c),
DataModelField(data_type=data_type_z),
],
reference=reference_d,
),
BaseModel(
fields=[DataModelField(data_type=data_type_v)],
reference=reference_z,
),
]
with pytest.raises(Exception):
sort_data_models(reference)
def test_sort_data_models():
reference = [
BaseModel(name='A', reference_classes=['A', 'C'], fields=[]),
BaseModel(name='B', reference_classes=['B'], fields=[]),
BaseModel(name='C', reference_classes=['B'], fields=[]),
]
unresolved, resolved, require_update_action_models = sort_data_models(reference)
expected = OrderedDict()
expected['B'] = reference[1]
expected['C'] = reference[2]
expected['A'] = reference[0]
assert resolved == expected
assert unresolved == []
assert require_update_action_models == ['B', 'A']
def parse(
self,
with_import: Optional[bool] = True,
format_: Optional[bool] = True
) -> Union[str, Dict[Tuple[str, ...], str]]:
for obj_name, raw_obj in self.base_parser.specification['components'][
'schemas'].items(): # type: str, Dict
obj = JsonSchemaObject.parse_obj(raw_obj)
if obj.is_object:
self.parse_object(obj_name, obj)
elif obj.is_array:
self.parse_array(obj_name, obj)
elif obj.enum:
self.parse_enum(obj_name, obj)
elif obj.allOf:
self.parse_all_of(obj_name, obj)
else:
self.parse_root_type(obj_name, obj)
if with_import:
if self.target_python_version == PythonVersion.PY_37:
self.imports.append(IMPORT_ANNOTATIONS)
_, sorted_data_models, require_update_action_models = sort_data_models(
self.results)
results: Dict[Tuple[str, ...], str] = {}
module_key = lambda x: (*x.name.split('.')[:-1], )
grouped_models = groupby(sorted(sorted_data_models.values(),
key=module_key),
key=module_key)
for module, models in ((k, [*v]) for k, v in grouped_models):
module_path = '.'.join(module)
result: List[str] = []
imports = Imports()
models_to_update: List[str] = []
for model in models:
if model.name in require_update_action_models:
models_to_update += [model.name]
imports.append(model.imports)
for ref_name in model.reference_classes:
if '.' not in ref_name:
continue
ref_path = ref_name.rsplit('.', 1)[0]
if ref_path == module_path:
continue
imports.append(Import(from_='.', import_=ref_path))
if with_import:
result += [imports.dump(), self.imports.dump(), '\n']
code = dump_templates(models)
result += [code]
if self.dump_resolve_reference_action is not None:
result += [
'\n',
self.dump_resolve_reference_action(models_to_update)
]
body = '\n'.join(result)
if format_:
body = format_code(body, self.target_python_version)
if module:
module = (*module[:-1], f'{module[-1]}.py')
parent = (*module[:-1], '__init__.py')
if parent not in results:
results[parent] = ''
else:
module = ('__init__.py', )
results[module] = body
# retain existing behaviour
if [*results] == [('__init__.py', )]:
return results[('__init__.py', )]
return results
