| 1 |
import re |
| 2 |
from pathlib import Path |
| 3 |
|
| 4 |
from .generatorbase import GeneratorBase |
| 5 |
from .model import ( |
| 6 |
ReferenceManual, |
| 7 |
Function, |
| 8 |
Object, |
| 9 |
PosArg, |
| 10 |
VarArgs, |
| 11 |
Kwarg, |
| 12 |
ObjectType, |
| 13 |
) |
| 14 |
|
| 15 |
import typing as T |
| 16 |
|
| 17 |
class GeneratorTypes(GeneratorBase): |
| 18 |
def __init__( |
| 19 |
self, manual: ReferenceManual, out: Path, enable_modules: bool |
| 20 |
) -> None: |
| 21 |
super().__init__(manual) |
| 22 |
self.out = out |
| 23 |
self.enable_modules = enable_modules |
| 24 |
|
| 25 |
def _parse_type(self, t, in_container=False): |
| 26 |
parsed = [] |
| 27 |
name = "" |
| 28 |
i = 0 |
| 29 |
while i < len(t): |
| 30 |
c = t[i] |
| 31 |
if c == '[': |
| 32 |
(n, sub) = self._parse_type(t[i+1:], in_container=True) |
| 33 |
parsed.append((name, sub,)) |
| 34 |
name = "" |
| 35 |
i += n + 1 |
| 36 |
continue |
| 37 |
elif c == ']': |
| 38 |
if name: |
| 39 |
parsed.append(name) |
| 40 |
return (i+1, parsed) |
| 41 |
elif c == ' ': |
| 42 |
i += 1 |
| 43 |
continue |
| 44 |
elif c == '|': |
| 45 |
if name: |
| 46 |
parsed.append(name) |
| 47 |
name = "" |
| 48 |
else: |
| 49 |
name += c |
| 50 |
|
| 51 |
i += 1 |
| 52 |
|
| 53 |
if name: |
| 54 |
parsed.append(name) |
| 55 |
return (i, parsed) |
| 56 |
|
| 57 |
def parse_type(self, t): |
| 58 |
(_, parsed) = self._parse_type(t) |
| 59 |
return parsed |
| 60 |
|
| 61 |
def assemble_type(self, t): |
| 62 |
if type(t) is list: |
| 63 |
def sort_func(v): |
| 64 |
assert type(v) is not list |
| 65 |
|
| 66 |
if type(v) is tuple: |
| 67 |
return v[0] |
| 68 |
else: |
| 69 |
return v |
| 70 |
|
| 71 |
t.sort(key=sort_func) |
| 72 |
return "|".join(self.assemble_type(x) for x in t) |
| 73 |
elif type(t) is tuple: |
| 74 |
return t[0] + '[' + self.assemble_type(t[1]) + ']' |
| 75 |
else: |
| 76 |
return t |
| 77 |
|
| 78 |
def print_types(self, args): |
| 79 |
args = [args] if not isinstance(args, list) else args |
| 80 |
|
| 81 |
res = [] |
| 82 |
for arg in args: |
| 83 |
t = self.assemble_type(self.parse_type(arg.type.raw)) |
| 84 |
res.append(f" {t}") |
| 85 |
|
| 86 |
return res |
| 87 |
|
| 88 |
|
| 89 |
def function_name(self, f: Function, o: Object = None) -> str: |
| 90 |
name = "" |
| 91 |
if o is not None: |
| 92 |
name += f"{o.name}." |
| 93 |
|
| 94 |
name += f.name |
| 95 |
return name |
| 96 |
|
| 97 |
def generate_function(self, f: Function, obj: Object = None): |
| 98 |
res = [] |
| 99 |
res.append(self.function_name(f, obj)) |
| 100 |
|
| 101 |
if f.posargs: |
| 102 |
res.append(' posargs:') |
| 103 |
res.extend(self.print_types(f.posargs)) |
| 104 |
|
| 105 |
if f.varargs: |
| 106 |
res.append(' varargs:') |
| 107 |
res.extend(self.print_types(f.varargs)) |
| 108 |
|
| 109 |
if f.optargs: |
| 110 |
res.append(' optargs:') |
| 111 |
res.extend(self.print_types(f.optargs)) |
| 112 |
|
| 113 |
kwargs = self.sorted_and_filtered(list(f.kwargs.values())) |
| 114 |
if kwargs: |
| 115 |
res.append(' kwargs:') |
| 116 |
for kwarg in kwargs: |
| 117 |
k = kwarg.name |
| 118 |
t = self.assemble_type(self.parse_type(kwarg.type.raw)) |
| 119 |
res.append(f" {k}: {t}") |
| 120 |
|
| 121 |
res.append(' returns:') |
| 122 |
res.append(' ' + self.assemble_type(self.parse_type(f.returns.raw))) |
| 123 |
|
| 124 |
return res |
| 125 |
|
| 126 |
def generate(self): |
| 127 |
lines = [] |
| 128 |
|
| 129 |
for f in self.sorted_and_filtered(self.functions): |
| 130 |
lines.extend(self.generate_function(f, None)) |
| 131 |
|
| 132 |
for obj in self.sorted_and_filtered(self.objects): |
| 133 |
for f in self.sorted_and_filtered(obj.methods): |
| 134 |
if not self.enable_modules and (obj.obj_type == ObjectType.MODULE or obj.defined_by_module is not None): |
| 135 |
continue |
| 136 |
|
| 137 |
lines.extend(self.generate_function(f, obj)) |
| 138 |
|
| 139 |
self.out.write_text("\n".join(lines) + "\n", encoding="utf-8") |