...

_archive/openapi/generator/model_generator.py

@@ -0,0 +1,188 @@
+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}")