pyluwen 0.5.2

Python bindings for luwen
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

# Extremely heavily inspired by https://github.com/huggingface/tokenizers/blob/main/bindings/python/stub.py

import argparse
import inspect
from pathlib import Path

INDENT = " " * 4
GENERATED_COMMENT = "# Generated content DO NOT EDIT\n"

def do_indent(text: str, indent: str):
    return text.replace("\n", f"\n{indent}")

def function(obj, indent, text_signature=None):
    if text_signature is None:
        text_signature = obj.__text_signature__.replace("$self", "self")
    string = ""
    string += f"{indent}def {obj.__name__}{text_signature}:\n"
    indent += INDENT
    string += f'{indent}"""\n'
    if obj.__doc__ is not None and len(obj.__doc__) > 0:
        string += f"{indent}{do_indent(obj.__doc__, indent)}\n"
    string += f'{indent}"""\n'
    string += f"{indent}pass\n"
    string += "\n"
    return string

def member_sort(member):
    if inspect.isclass(member):
        value = 10 + len(inspect.getmro(member))
    else:
        value = 1
    return value

def fn_predicate(obj):
    value = inspect.ismethoddescriptor(obj) or inspect.isbuiltin(obj)
    if value:
        return obj.__text_signature__ and not obj.__name__.startswith("_")
    if inspect.isgetsetdescriptor(obj):
        return obj.__doc__ is not None and not obj.__name__.startswith("_")
    return False

def get_module_members(module):
    members = [
        member
        for name, member in inspect.getmembers(module)
        if not name.startswith("_") and not inspect.ismodule(member)
    ]
    members.sort(key=member_sort)
    return members


def pyi_file(obj, indent=""):
    string = ""
    if inspect.ismodule(obj):
        string += GENERATED_COMMENT
        members = get_module_members(obj)
        for member in members:
            string += pyi_file(member, indent)

    elif inspect.isclass(obj):
        indent += INDENT
        mro = inspect.getmro(obj)
        if len(mro) > 2:
            inherit = f"({mro[1].__name__})"
        else:
            inherit = ""
        string += f"class {obj.__name__}{inherit}:\n"

        body = ""
        if obj.__doc__ is not None and len(obj.__doc__) > 0:
            body += f'{indent}"""\n{indent}{do_indent(obj.__doc__, indent)}\n{indent}"""\n'

        fns = inspect.getmembers(obj, fn_predicate)

        # Init
        if obj.__text_signature__ is not None:
            sig = obj.__text_signature__
            if not sig.startswith("(self"):
                sig = sig.replace("(", "(self, ")
            body += f"{indent}def __init__{sig}:\n"
            body += f"{indent+INDENT}pass\n"
            body += "\n"

        for (name, fn) in fns:
            body += pyi_file(fn, indent=indent)

        if len(body) > 0:
            body += f"{indent}pass\n"

        string += body
        if not string.endswith("\n\n"):
            string += "\n"

    elif inspect.isbuiltin(obj):
        string += f"{indent}@staticmethod\n"
        string += function(obj, indent)

    elif inspect.ismethoddescriptor(obj):
        string += function(obj, indent)

    elif inspect.isgetsetdescriptor(obj):
        string += f"{indent}@property\n"
        string += function(obj, indent, text_signature="(self)")
    else:
        raise Exception(f"Object {obj} is not supported")
    return string


def py_file(module, origin):
    members = get_module_members(module)

    string = GENERATED_COMMENT
    string += f"from .. import {origin}\n"
    string += "\n"
    for member in members:
        name = member.__name__
        string += f"{name} = {origin}.{name}\n"
    return string


# def do_black(content, is_pyi):
#     mode = black.Mode(
#         target_versions={black.TargetVersion.PY35},
#         line_length=119,
#         is_pyi=is_pyi,
#         string_normalization=True,
#         experimental_string_processing=False,
#     )
#     try:
#         return black.format_file_contents(content, fast=True, mode=mode)
#     except black.NothingChanged:
#         return content


def write(module, pyi_filename, check=False):
    submodules = [(name, member) for name, member in inspect.getmembers(module) if inspect.ismodule(member)]

    pyi_content = pyi_file(module)
    with open(pyi_filename, "w") as f:
        f.write(pyi_content)

    assert len(submodules) == 0, "There are now submodules for pyluwen, you should extend this to support generating .pyi files for them"

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--check", action="store_true")

    args = parser.parse_args()
    from pyluwen import pyluwen

    write(pyluwen, Path(__file__).parent.joinpath("pyluwen.pyi"), check=args.check)

if __name__ == "__main__":
    main()