108 lines
3.7 KiB
Python
108 lines
3.7 KiB
Python
import sys
|
|
import inspect
|
|
import logging
|
|
|
|
|
|
class InterfaceGenerator:
|
|
known = []
|
|
classes = {}
|
|
mapper = {
|
|
"str": "string",
|
|
"int": "number",
|
|
"float": "number",
|
|
"date": "Date",
|
|
"datetime": "Date",
|
|
"NoneType": "null",
|
|
"bool": "boolean",
|
|
}
|
|
|
|
def __init__(self, namespace, filename, logger=logging.getLogger()):
|
|
self.basename = ""
|
|
self.namespace = namespace
|
|
self.filename = filename
|
|
self.this_type = None
|
|
self.logger = logger
|
|
|
|
def pytype(self, cls):
|
|
a = self._pytype(cls)
|
|
return a
|
|
|
|
def _pytype(self, cls):
|
|
import typing
|
|
|
|
origin = typing.get_origin(cls)
|
|
arguments = typing.get_args(cls)
|
|
|
|
if origin is typing.ForwardRef: # isinstance(cls, typing.ForwardRef):
|
|
return "", "this" if cls.__forward_arg__ == self.this_type else cls.__forward_arg__
|
|
if origin is typing.Union:
|
|
|
|
if len(arguments) == 2 and arguments[1] is type(None):
|
|
return "?", self.pytype(arguments[0])[1]
|
|
else:
|
|
return "", "|".join([self.pytype(pt)[1] for pt in arguments])
|
|
if origin is list:
|
|
return "", "Array<{}>".format("|".join([self.pytype(a_type)[1] for a_type in arguments]))
|
|
if cls is typing.Any:
|
|
return "", "any"
|
|
|
|
name = cls.__name__ if hasattr(cls, "__name__") else cls if isinstance(cls, str) else None
|
|
if name is not None:
|
|
if name in self.mapper:
|
|
return "", self.mapper[name]
|
|
else:
|
|
return "", name
|
|
self.logger.warning(f"This python version might not detect all types (try >= 3.9). Could not identify >{cls}<")
|
|
return "?", "any"
|
|
|
|
def walker(self, module):
|
|
if sys.version_info < (3, 9):
|
|
raise RuntimeError("Python >= 3.9 is required to export API")
|
|
import typing
|
|
|
|
if (
|
|
inspect.ismodule(module[1])
|
|
and module[1].__name__.startswith(self.basename)
|
|
and module[1].__name__ not in self.known
|
|
):
|
|
self.known.append(module[1].__name__)
|
|
for cls in inspect.getmembers(module[1], lambda x: inspect.isclass(x) or inspect.ismodule(x)):
|
|
self.walker(cls)
|
|
elif (
|
|
inspect.isclass(module[1])
|
|
and module[1].__module__.startswith(self.basename)
|
|
and module[0] not in self.classes
|
|
and not module[0].startswith("_")
|
|
and hasattr(module[1], "__annotations__")
|
|
):
|
|
self.this_type = module[0]
|
|
|
|
d = {}
|
|
for param, ptype in typing.get_type_hints(module[1], globalns=None, localns=None).items():
|
|
if not param.startswith("_") and not param.endswith("_"):
|
|
|
|
d[param] = self.pytype(ptype)
|
|
|
|
if len(d) == 1:
|
|
key, value = d.popitem()
|
|
self.classes[module[0]] = value[1]
|
|
else:
|
|
self.classes[module[0]] = d
|
|
|
|
def run(self, models):
|
|
self.basename = models.__name__
|
|
self.walker(("models", models))
|
|
|
|
def write(self):
|
|
with (open(self.filename, "w") if self.filename else sys.stdout) as file:
|
|
file.write("declare namespace {} {{\n".format(self.namespace))
|
|
for cls, params in self.classes.items():
|
|
if isinstance(params, str):
|
|
file.write("\ttype {} = {};\n".format(cls, params))
|
|
else:
|
|
file.write("\tinterface {} {{\n".format(cls))
|
|
for name in params:
|
|
file.write("\t\t{}{}: {};\n".format(name, *params[name]))
|
|
file.write("\t}\n")
|
|
file.write("}\n")
|