def get_response_imports(definitions: dict):
imports = []
for value in definitions.values():
properties = value.get("properties", {})
response = properties.get("response", {})
ref = response.get("$ref")
if ref:
imports.append(get_type_from_reference(ref))
continue
if response.get("PatternProperties"):
continue
for item in [*response.get("properties", {}).values(), response]:
if item.get("type") == "array":
ref = item["items"].get("$ref")
if not ref and item["items"].get("type") == "object":
for property_item in item["items"]["properties"].values():
property_ref = property_item.get("$ref")
if property_ref:
imports.append(
get_type_from_reference(property_ref))
else:
ref = item.get("$ref")
if ref:
imports.append(get_type_from_reference(ref))
return {"vkbottle_types.objects": sorted(set(imports))}
def jsonschema_object_factory(classname: str, json_properties: dict) -> 'Model':
schema_type = json_properties['response'].get('type', '$ref')
if schema_type == '$ref':
t = get_type_from_reference(json_properties['response']['$ref'])
t = Annotation.type_string_to_default_type(t)
return SingleTypeModel(classname, f'Optional[{t}]')
elif schema_type == 'integer':
return SingleTypeModel(classname, 'int')
elif schema_type == 'boolean':
return SingleTypeModel(classname, 'bool')
elif schema_type == 'array':
type_ = None
if json_properties['response']['items'].get('type'):
type_ = json_properties['response']['items']['type']
type_ = Annotation('Array', list_inner_type=type_)
else:
type_ = json_properties['response']['items']['$ref']
type_ = get_type_from_reference(type_)
return SingleTypeModel(classname, f'List[{type_}]')
elif schema_type == 'string':
return SingleTypeModel(classname, 'string')
else:
# HARDCODED THIS IS UNIQUE CASE
if json_properties['response'].get('patternProperties'):
return SingleTypeModel(classname, 'typing.Dict[str, int]')
properties = json_properties['response']['properties']
names = {name: None for name in properties.keys()}
json_properties = {name: None for name in names}
types = []
for _, value in properties.items():
if value.get('type'):
property_type = value.get('type')
if property_type == 'array':
ref_type = value['items'].get('$ref')
if ref_type:
types.append([get_type_from_reference(ref_type)])
else:
types.append([value['items']['type']])
else:
types.append(value['type'])
else:
t = get_type_from_reference(value['$ref'])
types.append(t)
return ResponseModel(classname, types, **json_properties)
def jsonschema_object_factory(classname: str, json_properties: dict):
schema_type = json_properties["response"].get("type", "$ref")
if schema_type == "array":
type_ = json_properties["response"]["items"].get("type")
if type_ == "object":
properties = json_properties["response"]["items"]["properties"]
return ResponseModel(classname, get_types(properties),
**properties)
return ""
elif (schema_type in [
"$ref",
"integer",
"number",
"string",
"boolean",
] or json_properties["response"].get("patternProperties")):
return ""
superclass = "BaseResponse"
all_of = json_properties["response"].get("allOf")
if all_of:
for item in all_of:
ref = item.get("$ref")
if ref:
superclass = get_type_from_reference(ref)
continue
properties = item["properties"]
else:
properties = json_properties["response"]["properties"]
names = {name: None for name in properties.keys()}
json_properties = {name: None for name in names}
types = get_types(properties)
return ResponseModel(classname, types, superclass, **json_properties)
def write_response_alias(schema_body: dict) -> None:
text = ""
annotations = {}
for classname, value in schema_body.items():
schema_type = value["properties"]["response"].get("type", "$ref")
if schema_type == "$ref":
annotation = convert_to_python_type(
get_type_from_reference(
value["properties"]["response"]["$ref"]))
elif schema_type == "array":
type_ = value["properties"]["response"]["items"].get("type")
if not type_:
type_ = value["properties"]["response"]["items"]["$ref"]
annotation = f'typing.List["{get_type_from_reference(type_)}"]'
elif type_ == "object":
annotation = f'typing.List["{classname}Model"]'
else:
annotation = f"typing.List[{convert_to_python_type(type_)}]"
# HARDCODED THIS IS UNIQUE CASE
elif value["properties"]["response"].get("patternProperties"):
annotation = "typing.Dict[str, int]"
elif schema_type == "object":
annotation = f'"{classname}Model"'
else:
annotation = convert_to_python_type(schema_type)
annotations[classname] = annotation
properties = {"response: " + annotation: None}
text += str(ResponseModel(classname, **properties))
return text, annotations
def __init__(self, classname, prepared_dict):
self.class_form: ClassForm = ClassForm(classname)
super_classes_list = []
for element in prepared_dict[classname]["allOf"]:
properties = element.get("properties")
required = prepared_dict[classname].get("required", [])
reference = element.get("$ref")
if properties:
for name in sorted(properties.keys()):
type_anno = get_annotation_type(properties[name])
text = properties[name].get("description")
self.class_form.add_param(
name,
None,
type=properties[name].get("type"),
annotation=type_anno,
required=name in required,
)
self.class_form.add_description_row(name, text)
if reference:
ref = get_type_from_reference(reference)
super_classes_list.append(ref)
if super_classes_list:
formatted = ", ".join(super_classes_list)
if len(formatted) >= 80:
formatted = "\n\t" + formatted.replace(", ", ",\n\t") + "\n"
self.class_form.set_super_class(formatted)
def schema_object_fabric_method(classname, prepared_dict):
json_type = prepared_dict[classname]
if json_type.get("type") == "object":
if json_type.get("allOf"):
return SchemaAllOfObject(classname, prepared_dict)
elif json_type.get("properties"):
return SchemaObject(classname, prepared_dict)
elif json_type.get("oneOf"):
return SchemaOneOfObject(classname, prepared_dict)
elif json_type.get("type") == "string":
# if enum is numerical
if not json_type.get("enum"):
return SchemaUndefined(classname)
elif isinstance(json_type["enum"][0], int):
return SchemaEnumInitialized(classname, prepared_dict)
else:
return SchemaEnum(classname, prepared_dict)
elif json_type.get("type") == "integer":
return SchemaEnumInitialized(classname, prepared_dict)
elif json_type.get("type") == "boolean":
return SchemaBoolean(classname, prepared_dict)
elif json_type.get("type") == "array":
return SchemaArray(classname, prepared_dict)
elif json_type.get("$ref"):
predecessor = get_type_from_reference(json_type["$ref"])
return SchemaReference(classname, prepared_dict, predecessor)
elif json_type.get("type") is None:
return SchemaUndefined(classname)
def get_types(properties: dict):
types = []
for value in properties.values():
property_type = value.get("type")
if not property_type:
t = get_type_from_reference(value["$ref"])
types.append(t)
continue
elif property_type == "array":
ref_type = value["items"].get("$ref")
if not ref_type:
types.append([value["items"]["type"]])
continue
types.append([get_type_from_reference(ref_type)])
else:
types.append(value["type"])
return types
def get_references(item: dict):
references = []
all_of = item.get("allOf", [])
one_of = item.get("oneOf", [])
for i in [*all_of, *one_of, item]:
reference = i.get("$ref")
if reference:
references.append(get_type_from_reference(reference, False))
return references
def __init__(self, classname, prepared_dict):
self.class_form: ClassForm = ClassForm(classname)
for name in prepared_dict[classname]['properties'].keys():
properties = prepared_dict[classname]['properties']
if properties[name].get('type') == 'array':
if properties[name]['items'].get('type'):
type_anno = [properties[name]['items']['type']]
else:
type_anno = properties[name]['items'].get('$ref')
type_anno = [get_type_from_reference(type_anno)]
elif properties[name].get('type'):
type_anno = properties[name].get('type')
else:
type_anno = properties[name].get('$ref')
type_anno = get_type_from_reference(type_anno)
text = properties[name].get('description')
self.class_form.add_param(name, None, annotation=type_anno)
self.class_form.add_description_row(name, text)
def __str__(self):
items = self.params["items"]
param_type = self.params["type"]
param_annotate = convert_to_python_type(self.params['annotate'])
if param_annotate == 'list' and items.get("$ref", items.get("type")):
post_annotate = (get_type_from_reference(items["$ref"])
if items.get("$ref") else items["type"])
param_annotate = "List[%s]" % convert_to_python_type(post_annotate)
if param_type is False:
return f"Optional[{param_annotate}] = None"
return param_annotate
def __init__(self, classname, prepared_dict):
self.class_form: ClassForm = ClassForm(classname)
super_classes_list = []
for element in prepared_dict[classname]['allOf']:
properties = element.get('properties')
reference = element.get('$ref')
if properties:
for name in properties.keys():
text = properties[name].get('description')
self.class_form.add_param(name, None)
self.class_form.add_description_row(name, text)
if reference:
ref = get_type_from_reference(reference)
super_classes_list.append(ref)
self.class_form.set_super_class(",\n\t".join(super_classes_list))
def __init__(self, classname, prepared_dict):
one_of = prepared_dict[classname]["oneOf"]
references = [element.get("$ref") for element in one_of]
if all(references):
self.class_form: ClassForm = ClassForm(classname)
super_classes_list = []
for reference in references:
ref = get_type_from_reference(reference)
super_classes_list.append(ref)
if super_classes_list:
formatted = ", ".join(super_classes_list)
if len(formatted) >= 80:
formatted = "\n\t" + formatted.replace(", ",
",\n\t") + "\n"
self.class_form.set_super_class(formatted)
else:
types = ", ".join(
convert_to_python_type(item["type"]) for item in one_of)
self.class_form = f"\n\n{classname} = typing.Union[{types}]\n"
def test_get_type_from_reference(test_input, expected):
assert get_type_from_reference(test_input) == expected
