...

_archive/openrpc/generator/client/generator.py

@@ -0,0 +1,77 @@
+from typing import Dict, List, Optional, Union
+from urllib.parse import urlparse
+
+from heroserver.openrpc.generator.code.lang_code_generator import LangCodeGenerator
+from heroserver.openrpc.generator.model.model_generator import ModelGenerator
+
+from heroserver.openrpc.model.common import (
+    ContentDescriptorObject,
+    ReferenceObject,
+)
+from heroserver.openrpc.model.openrpc_spec import OpenRPCSpec
+
+
+class ClientGenerator:
+    def __init__(
+        self,
+        spec: OpenRPCSpec,
+        lang_code_generator: LangCodeGenerator,
+        output_file: str,
+    ) -> None:
+        self.spec = spec
+        self.model_generator = ModelGenerator(spec, lang_code_generator)
+        self.lang_code_generator = lang_code_generator
+        self.output_file = output_file
+
+    def generate_client(self):
+        code_pre = self.lang_code_generator.generate_imports()
+        code_models = self.model_generator.generate_models()
+        code_methods = self.generate_methods()
+
+        # Write the generated code to a file
+        with open(self.output_file, "w") as file:
+            file.write(code_pre)
+            file.write("\n")
+            file.write(code_models)
+            file.write("\n")
+            file.write(code_methods)
+
+        print(f"Generated API code has been written to {self.output_file}")
+
+    def generate_methods(self):
+        servers = self.spec.servers
+        base_url = "http://localhost:8000"
+        if servers:
+            base_url = servers[0].url
+
+        url = urlparse(base_url)
+        methods = []
+        for method_spec in self.spec.methods:
+            params: Dict[str, str] = {}
+            for param in method_spec.params:
+                params[param.name] = self.model_generator.jsonschema_to_type(
+                    ["methods", method_spec.name, "params", param.name],
+                    param.schema,
+                )
+
+            return_type = self.method_result_return_type(["methods", method_spec.name, "result"], method_spec.result)
+            methods.append(self.lang_code_generator.generate_method(method_spec, url, params, return_type))
+
+        return "\n\n".join(methods)
+
+    def method_result_return_type(
+        self,
+        path: List[str],
+        method_result: Optional[Union[ContentDescriptorObject, ReferenceObject]],
+    ) -> str:
+        if not method_result:
+            type_name = ""
+
+        if isinstance(method_result, ContentDescriptorObject):
+            schema = method_result.schema
+            type_name = self.model_generator.jsonschema_to_type(path, schema)
+
+        elif isinstance(method_result, ReferenceObject):
+            type_name = self.model_generator.jsonschema_to_type(path, method_result)
+
+        return type_name