189 lines
7.0 KiB
Python
189 lines
7.0 KiB
Python
from typing import Dict, List, Set, Any
|
|
|
|
class VlangCodeGenerator:
|
|
pass
|
|
|
|
class ModelGenerator:
|
|
def __init__(
|
|
self, spec: Dict[str, Any], lang_code_generator: str
|
|
) -> None:
|
|
self.spec = spec
|
|
self.lang_code_generator = lang_code_generator
|
|
# self.processed_objects: Dict[str, Dict[str, str]] = {}
|
|
# self.ordered_objects: List[str] = []
|
|
# self.used_names: Set[str] = set()
|
|
|
|
def generate_models(self):
|
|
if self.lang_code_generator != "vlang":
|
|
raise ValueError('Unsupported language.')
|
|
|
|
|
|
if not self.spec.get('components'):
|
|
raise ValueError("No components found in spec")
|
|
|
|
components = self.spec['components']
|
|
|
|
if not components.get('schemas'):
|
|
raise ValueError("No schemas found in components")
|
|
|
|
schemas = components['schemas']
|
|
schemas_path = ["components", "schemas"]
|
|
for name, schema in schemas.items():
|
|
self.jsonschema_to_type(
|
|
path=schemas_path + [name],
|
|
jsonschema=schema,
|
|
)
|
|
|
|
objects_code = ""
|
|
for val in self.ordered_objects:
|
|
if val == "":
|
|
continue
|
|
objects_code = f"{objects_code}{val}\n\n"
|
|
|
|
print(f'debugzo4 {objects_code}')
|
|
return objects_code
|
|
|
|
# def jsonschema_to_type(
|
|
# self, path: List[str], jsonschema: SchemaObject | ReferenceObject
|
|
# ) -> str:
|
|
# if isinstance(jsonschema, ReferenceObject):
|
|
# ref: str = jsonschema.ref
|
|
|
|
# ref_schema = self.spec.ref_to_schema(ref)
|
|
# ref_path = ref.split("/")[1:]
|
|
|
|
# if isinstance(ref_schema, ContentDescriptorObject):
|
|
# # TODO: implement
|
|
# raise Exception("unimplemented")
|
|
# # return self.content_descriptor_to_type(ref_path, ref_schema)
|
|
|
|
# return self.jsonschema_to_type(ref_path, ref_schema)
|
|
|
|
# path_str = "/".join([item.lower() for item in path])
|
|
# if path_str in self.processed_objects:
|
|
# return self.processed_objects[path_str]["name"]
|
|
|
|
# type_name = self.type_name_from_path(path)
|
|
|
|
# description = getattr(jsonschema, 'description', None)
|
|
# if jsonschema.enum:
|
|
# enum = jsonschema.enum
|
|
# type_code = self.lang_code_generator.generate_enum(enum, type_name)
|
|
# if self.lang_code_generator.is_primitive(type_code):
|
|
# return type_code
|
|
|
|
# self.add_object(path_str, type_code, type_name)
|
|
# return type_name
|
|
|
|
# if jsonschema.type:
|
|
# match jsonschema.type:
|
|
# case "string":
|
|
# return self.lang_code_generator.string_primitive()
|
|
|
|
# case "integer":
|
|
# return self.lang_code_generator.integer_primitive()
|
|
|
|
# case "number":
|
|
# return self.lang_code_generator.number_primitive()
|
|
|
|
# case "array":
|
|
# if isinstance(jsonschema.items, List):
|
|
# raise Exception(
|
|
# "array of different item types is not supported"
|
|
# )
|
|
|
|
# item_type_name = self.jsonschema_to_type(
|
|
# path + ["item"], jsonschema.items
|
|
# )
|
|
# return self.lang_code_generator.array_of_type(
|
|
# item_type_name
|
|
# )
|
|
|
|
# case "boolean":
|
|
# return self.lang_code_generator.bool_primitive()
|
|
|
|
# case "object":
|
|
# # to prevent cyclic dependencies
|
|
# self.add_object(path_str, "", type_name)
|
|
|
|
# properties: Dict[str, PropertyInfo] = {}
|
|
# for (
|
|
# property_name,
|
|
# property_schema,
|
|
# ) in jsonschema.properties.items():
|
|
# schema = property_schema
|
|
# new_path = path + ["properties", property_name]
|
|
# if isinstance(property_schema, ReferenceObject):
|
|
# schema = self.spec.ref_to_schema(
|
|
# property_schema.ref
|
|
# )
|
|
# new_path = property_schema.ref.split("/")[1:]
|
|
|
|
# property_info = PropertyInfo(
|
|
# name=property_name,
|
|
# type_name=self.jsonschema_to_type(new_path, schema),
|
|
# description=schema.description,
|
|
# example=schema.example,
|
|
# )
|
|
|
|
# properties[property_name] = property_info
|
|
|
|
# type_code = self.lang_code_generator.generate_object(
|
|
# type_name, properties
|
|
# )
|
|
# self.add_object(path_str, type_code, type_name)
|
|
# return type_name
|
|
|
|
# case "null":
|
|
# return self.lang_code_generator.null_primitive()
|
|
|
|
# case _:
|
|
# raise Exception(f"type {jsonschema.type} is not supported")
|
|
|
|
# if jsonschema.anyOf:
|
|
# type_names = []
|
|
# for i, item in enumerate(jsonschema.anyOf):
|
|
# type_names.append(
|
|
# self.jsonschema_to_type(path + [f"anyOf{i}"], item)
|
|
# )
|
|
|
|
# return self.lang_code_generator.generate_multitype(type_names)
|
|
# # self.add_object(path_str, type_code, type_code)
|
|
# # return type_code
|
|
|
|
# elif jsonschema.oneOf:
|
|
# type_names = []
|
|
# for i, item in enumerate(jsonschema.oneOf):
|
|
# type_names.append(
|
|
# self.jsonschema_to_type(path + [f"oneOf{i}"], item)
|
|
# )
|
|
|
|
# return self.lang_code_generator.generate_multitype(type_names)
|
|
# # self.add_object(path_str, type_code, type_code)
|
|
# # return type_code
|
|
|
|
# elif jsonschema.allOf:
|
|
# return self.lang_code_generator.encapsulate_types(jsonschema.allOf)
|
|
# # self.add_object(path_str, type_code, type_code)
|
|
# # return type_name
|
|
|
|
# raise Exception(f"type {jsonschema.type} is not supported")
|
|
|
|
# def add_object(self, path_str: str, type_code: str, type_name: str):
|
|
# self.used_names.add(type_name)
|
|
# self.processed_objects[path_str] = {
|
|
# "code": type_code,
|
|
# "name": type_name,
|
|
# }
|
|
# print(f'debugzo21 {self.processed_objects[path_str]}')
|
|
# self.ordered_objects.append(type_code)
|
|
|
|
# def type_name_from_path(self, path: List[str]) -> str:
|
|
# type_name = ""
|
|
# for item in reversed(path):
|
|
# type_name += item.title() if item.islower() else item
|
|
# if type_name not in self.used_names:
|
|
# return type_name
|
|
|
|
# raise Exception(f"failed to generate unique name from path: {path}")
|