if "$ref" in schema_type:

schema = schema_type.get("$ref").strip("# ")

ref_schema_type = spec

for step in schema.split("/"):

if step:

if step not in ref_schema_type:

raise ValueError(f"Could not find schema in spec: {schema}")

ref_schema_type = ref_schema_type[step]

return ref_schema_type

schema_type: dict[str, Any],

schema_path: list[str],

schema_to_class: dict[str, str],

classes,

*,

verbose: bool = False,

collect_new_schemas: list[str] | None = None,

) -> PythonType | GithubClass | None:

schema = None

data_type = schema_type.get("type")

if "$ref" in schema_type:

schema = schema_type.get("$ref").strip("# ")

elif "oneOf" in schema_type:

types = [

as_python_type(

t,

schema_path + ["oneOf", str(idx)],

schema_to_class,

classes,

verbose=verbose,

collect_new_schemas=collect_new_schemas,

)

for idx, t in enumerate(schema_type.get("oneOf"))

]

types = list({t for t in types if t is not None})

if len(types) == 0:

return None

if len(types) == 1:

return types[0]

return PythonType("union", sorted(types))

elif "allOf" in schema_type and len(schema_type.get("allOf")) == 1:

return as_python_type(

schema_type.get("allOf")[0],

schema_path + ["allOf", "0"],

schema_to_class,

classes,

verbose=verbose,

collect_new_schemas=collect_new_schemas,

)

if data_type == "object":

schema = "/".join([""] + schema_path)

if schema is not None:

# these schemas are explicitly ignored

if schema in {"/components/schemas/empty-object"}:

return None

if schema in schema_to_class:

classes_of_schema = schema_to_class[schema]

if not isinstance(classes_of_schema, list):

raise ValueError(f"Expected list of types for schema: {schema}")

if len(classes_of_schema) == 0:

raise ValueError(f"Expected non-empty list of types for schema: {schema}")

if len(classes_of_schema) == 1:

class_name = classes_of_schema[0]

if class_name not in classes:

if verbose:

print(f"Class not found in index: {class_name}")

return None

return GithubClass(**classes.get(class_name))

if verbose:

for class_name in classes:

if class_name not in classes:

print(f"Class not found in index: {class_name}")

return PythonType(

type="union",

inner_types=[GithubClass(**classes.get(cls)) for cls in sorted(classes_of_schema) if cls in classes],

)

if collect_new_schemas is not None:

collect_new_schemas.append(schema or ".".join([""] + schema_path))

if verbose:

print(f"Schema not implemented: {schema or '.'.join([''] + schema_path)}")

return PythonType(type="dict", inner_types=[PythonType("str"), PythonType("Any")])

if data_type is None:

if verbose:

print(f"There is no $ref and no type in schema: {json.dumps(schema_type)}")

return None

if data_type == "array":

return PythonType(

type="list",

inner_types=[

as_python_type(

schema_type.get("items"),

schema_path + ["items"],

schema_to_class,

classes,

verbose=verbose,

collect_new_schemas=collect_new_schemas,

)

],

)

format = schema_type.get("format")

data_types = {

"boolean": {None: "bool"},

"integer": {None: "int"},

"number": {None: "float"},

"string": {

None: "str",

"date-time": "datetime",

"uri": "str",

},

}

if data_type not in data_types:

if verbose:

print(f"Unsupported data type: {data_type}")

return None

formats = data_types.get(data_type)

type: str

inner_types: list[PythonType | GithubClass] | None = None

def __hash__(self):

return hash(self.__repr__())

def __repr__(self):

return (

f"{self.type}[{', '.join([str(inner) for inner in self.inner_types])}]" if self.inner_types else self.type

)

def __lt__(self, other) -> bool:

ids: list[str]

package: str

module: str

name: str

filename: str

test_filename: str

bases: list[str]

inheritance: list[str]

methods: dict

properties: dict

schemas: list[str]

docstring: str

def __hash__(self):

return hash(self.__repr__())

def __repr__(self):

return ".".join([self.package, self.module, self.name])

def __lt__(self, other) -> bool:

return self.__repr__() < other.__repr__()

@property

def short_class_name(self) -> str:

return self.name.split(".")[-1]

@property

def full_class_name(self) -> str:

return f"{self.package}.{self.module}.{self.name}"

@staticmethod

def from_class_name(

class_name: str, index: dict[str, Any] | None = None, github_parent_path: str = ""

) -> GithubClass:

if github_parent_path and not github_parent_path.endswith("/"):

github_parent_path = f"{github_parent_path}/"

if "." in class_name:

full_class_name = class_name

package, module, class_name = full_class_name.split(".", 2)

if index is not None:

clazz = GithubClass.from_class_name(class_name, index)

if clazz.package != package or clazz.module != module or clazz.name != class_name:

raise ValueError(f"Class mismatch: {full_class_name} vs {clazz}")

return clazz

else:

return GithubClass(

ids=[],

package="github",

module=class_name,

name=class_name,

filename=f"{github_parent_path}{package}/{module}.py",

test_filename=f"{github_parent_path}tests/{module}.py",

bases=[],

inheritance=[],

methods={},

properties={},

schemas=[],

docstring="",

)

else:

if index is not None:

classes = index.get("classes", {})

if class_name not in classes:

raise ValueError(f"Unknown class {class_name}")

cls = classes.get(class_name)

if any(key not in cls for key in ["package", "module", "name"]):

raise KeyError(f"Missing package, module or name in {cls}")

return GithubClass(**cls)

else:

return GithubClass.from_class_name(

f"github.{class_name}.{class_name}", github_parent_path=github_parent_path

def __init__(self):

super().__init__()

self._strings = []

@property

def strings(self):

return self._strings

def visit_SimpleString(self, node: cst.SimpleString) -> bool | None:

def __init__(self):

super().__init__()

self._calls = []

@property

def calls(self):

return self._calls

def visit_Call(self, node: cst.Call) -> bool | None:

code = cst.Module([]).code_for_node

func_name = code(node.func)

args = [(f"{code(arg.keyword)}=" if arg.keyword else "") + code(arg.value) for arg in node.args]

try:

if (

isinstance(node.body, IndentedBlock)

and isinstance(node.body.body[0], SimpleStatementLine)

and isinstance(node.body.body[0].body[0], Expr)

and isinstance(node.body.body[0].body[0].value, SimpleString)

):

return node.body.body[0].body[0].value.value

except Exception as e:

merged_paths = {}

for path_dict in paths:

for path, verbs in path_dict.items():

for verb, methods in verbs.items():

if path not in merged_paths:

merged_paths[path] = {}

if verb not in merged_paths[path]:

merged_paths[path][verb] = {}

if "methods" not in merged_paths[path][verb]:

merged_paths[path][verb]["methods"] = []

merged_paths[path][verb]["methods"].extend(methods.get("methods", []))

@staticmethod

def contains_decorator(seq: Sequence[cst.Decorator], decorator_name: str):

return any(d.decorator.value == decorator_name for d in seq if isinstance(d.decorator, cst.Name))

@classmethod

def is_github_object_property(cls, func_def: cst.FunctionDef):

return cls.contains_decorator(func_def.decorators, "property")

@classmethod

def create_subscript(cls, name: str) -> cst.Subscript:

fields = name.rstrip("]").split("[", maxsplit=1)

name = fields[0]

index = fields[1]

sub = cst.Subscript(cst.Name(name), [cst.SubscriptElement(cst.Index(cst.Integer(index)))])

return sub

@classmethod

def create_attribute(cls, names: list[str]) -> cst.BaseExpression:

names = [cls.create_subscript(name) if "[" in name and name.endswith("]") else cst.Name(name) for name in names]

if len(names) == 1:

return names[0]

attr = cst.Attribute(names[0], names[1])

for name in names[2:]:

attr = cst.Attribute(attr, name)

return attr

@classmethod

def create_type(

cls, data_type: PythonType | GithubClass | None, short_class_name: bool = False

) -> cst.BaseExpression:

if data_type is None:

return cst.Name("None")

if isinstance(data_type, GithubClass):

if short_class_name:

return cst.Name(data_type.name.split(".")[-1])

return cls.create_attribute([data_type.package, data_type.module] + data_type.name.split("."))

if data_type.type == "union":

if len(data_type.inner_types) == 0:

return cst.Name("None")

if len(data_type.inner_types) == 1:

return cls.create_type(data_type.inner_types[0], short_class_name)

result = cst.BinaryOperation(

cls.create_type(data_type.inner_types[0], short_class_name),

cst.BitOr(),

cls.create_type(data_type.inner_types[1], short_class_name),

)

for dt in data_type.inner_types[2:]:

result = cst.BinaryOperation(result, cst.BitOr(), cls.create_type(dt, short_class_name))

return result

if data_type.inner_types:

elems = [

cst.SubscriptElement(cst.Index(cls.create_type(elem, short_class_name)))

for elem in data_type.inner_types

]

return cst.Subscript(cst.Name(data_type.type), slice=elems)

return cst.Name(data_type.type)

@classmethod

def find_nodes(cls, node: cst.CSTNode, node_type: type[cst.CSTNode]) -> list[cst.CSTNode]:

if isinstance(node, node_type):

return [node]

return [node for child in node.children for node in cls.find_nodes(child, node_type)]

@staticmethod

def parse_attribute(attr: cst.Attribute) -> list[str]:

attrs = []

while (

isinstance(attr, cst.Attribute) or isinstance(attr, cst.Subscript) and isinstance(attr.value, cst.Attribute)

):

if isinstance(attr, cst.Attribute):

attrs.insert(0, attr.attr.value)

elif isinstance(attr, cst.Subscript):

# we do not extract a name, we skip to the subscript value

pass

attr = attr.value

attrs.insert(0, attr.value)

def __init__(self):

super().__init__()

self.visit_class_name = []

def visit_ClassDef(self, node: cst.ClassDef):

self.visit_class_name.append(node.name.value)

def leave_ClassDef(self, original_node: cst.ClassDef) -> None:

self.visit_class_name.pop()

@property

def current_class_name(self) -> str:

def __init__(self):

super().__init__()

self.visit_class_name = []

def visit_ClassDef(self, node: cst.ClassDef):

self.visit_class_name.append(node.name.value)

def leave_ClassDef(self, original_node: cst.ClassDef, updated_node: cst.ClassDef):

self.visit_class_name.pop()

return super().leave_ClassDef(original_node, updated_node)

@property

def current_class_name(self) -> str:

return ".".join(self.visit_class_name)

@staticmethod

def is_github_import(stmt: cst.Import | cst.ImportFrom) -> bool:

return (

isinstance(stmt, cst.Import)

and (

isinstance(stmt.names[0].name, cst.Name)

and stmt.names[0].name.value == "github"

or isinstance(stmt.names[0].name, cst.Attribute)

and stmt.names[0].name.value.value == "github"

)

or isinstance(stmt, cst.ImportFrom)

and isinstance(stmt.module, cst.Attribute)

and stmt.module.value.value == "github"

)

@staticmethod

def is_datetime_import(stmt: cst.Import | cst.ImportFrom) -> bool:

return (

isinstance(stmt, cst.ImportFrom)

and isinstance(stmt.module, cst.Name)

and stmt.module.value == "datetime"

and stmt.names

and isinstance(stmt.names[0], cst.ImportAlias)

and isinstance(stmt.names[0].name, cst.Name)

and stmt.names[0].name.value == "datetime"

)

@staticmethod

def add_datetime_import(node: cst.Module, index: int) -> cst.Module:

import_stmt = cst.SimpleStatementLine(

[

cst.ImportFrom(

cst.Name("datetime"), [cst.ImportAlias(cst.Name("datetime")), cst.ImportAlias(cst.Name("timezone"))]

)

]

)

stmts = list(node.body)

return node.with_changes(body=stmts[:index] + [import_stmt] + stmts[index:])

@staticmethod

def add_future_import(node: cst.Module) -> cst.Module:

stmts = list(node.body)

first_stmt = stmts[0] if stmts else None

if not (

first_stmt

and isinstance(first_stmt, cst.SimpleStatementLine)

and isinstance(first_stmt.body[0], cst.ImportFrom)

and isinstance(first_stmt.body[0].module, cst.Name)

and first_stmt.body[0].module.value == "__future__"

and first_stmt.body[0].names

and isinstance(first_stmt.body[0].names[0], cst.ImportAlias)

and isinstance(first_stmt.body[0].names[0].name, cst.Name)

and first_stmt.body[0].names[0].name.value == "annotations"

):

import_stmt = cst.SimpleStatementLine(

[cst.ImportFrom(cst.Name("__future__"), [cst.ImportAlias(cst.Name("annotations"))])]

)

if (

isinstance(first_stmt, cst.SimpleStatementLine)

and isinstance(first_stmt.body[0], (cst.Import, cst.ImportFrom))

and not first_stmt.leading_lines

):

first_stmt = first_stmt.with_changes(leading_lines=[cst.EmptyLine()])

stmts = [first_stmt] + stmts[1:]

node = node.with_changes(body=[import_stmt] + stmts)

def __init__(self, classes: dict[str, Any], paths: dict[str, Any], method_verbs: dict[str, str] | None):

super().__init__()

self._module = None

self._package = None

self._filename = None

self._test_filename = None

self._classes = classes

self._paths = paths

self._ids = []

self._properties = {}

self._methods = {}

self._method_verbs = method_verbs

def module(self, module: str):

self._module = module

def package(self, package: str):

self._package = package

def filename(self, filename: str):

self._filename = filename

def test_filename(self, test_filename: str):

self._test_filename = test_filename

@property

def classes(self) -> dict[str, Any]:

return self._classes

def leave_ClassDef(self, node: cst.ClassDef) -> bool | None:

class_name = self.current_class_name

class_name_short = node.name.value

class_docstring = get_class_docstring(node)

class_docstring = class_docstring.strip('"\r\n ') if class_docstring else None

class_schemas = []

class_bases = [

val if isinstance(val, str) else Module([]).code_for_node(val).split(".")[-1]

for base in node.bases

for val in [base.value.value]

]

# extract OpenAPI schema

if class_docstring:

lines = class_docstring.splitlines()

for idx, line in enumerate(lines):

if "The OpenAPI schema can be found at" in line:

while len(lines) > idx + 1 and not lines[idx + 1].strip():

idx = idx + 1

for schema in lines[idx + 1 :]:

if not schema.strip().lstrip("- "):

break

class_schemas.append(schema.strip().lstrip("- "))

if class_name_short in self._classes:

print(f"Duplicate class definition for {class_name_short}")

# TODO: ideally, the key should be the fully qualified class name and there

# should be an index from class_name to the fully qualified class name

self._classes[class_name_short] = {

"ids": self._ids,

"name": class_name,

"module": self._module,

"package": self._package,

"filename": self._filename,

"test_filename": self._test_filename,

"docstring": class_docstring,

"schemas": class_schemas,

"bases": class_bases,

"properties": self._properties,

"methods": self._methods,

}

self._ids = []

self._properties = {}

self._methods = {}

return super().leave_ClassDef(node)

@staticmethod

def return_types(return_type: str | None) -> list[str]:

if return_type is None:

return []

return_type = return_type.strip()

none = []

if return_type.startswith("None | "):

none = ["None"]

return_type = return_type[7:]

elif return_type.endswith("| None"):

none = ["None"]

return_type = return_type[:-7]

types = [return_type] + none

if "|" in return_type and "[" not in return_type:

types = return_type.split("|") + none

return [rt.strip().replace('"', "") for rt in types]

def visit_FunctionDef(self, node: cst.FunctionDef) -> None:

method_name = node.name.value

returns = self.return_types(cst.Module([]).code_for_node(node.returns.annotation) if node.returns else None)

if self.is_github_object_property(node):

self._properties[method_name] = {"name": method_name, "returns": returns}

visitor = SimpleStringCollector()

node.body.visit(visitor)

if visitor.strings:

string = [line for line in visitor.strings[0].splitlines() if ":calls:" in line]

if string:

fields = string[0].split(":calls:")[1].strip(" `").split(" ", maxsplit=2)

self._methods[method_name] = {

"name": method_name,

"call": {

"verb": fields[0] if len(fields) > 0 else None,

"path": fields[1] if len(fields) > 1 else None,

"docs": fields[2] if len(fields) > 2 else None,

},

"returns": returns,

}

if len(fields) > 1:

verb = fields[0]

path = fields[1]

if path not in self._paths:

self._paths[path] = {}

if verb not in self._paths[path]:

self._paths[path][verb] = {"methods": []}

self._paths[path][verb]["methods"].append(

{

"class": self.current_class_name,

"name": method_name,

"returns": returns,

}

)

# check if method (VERB) is same as in the code

if len(fields) > 0 and self._method_verbs is not None:

verb = f'"{fields[0]}"'

full_method_name = f"{self.current_class_name}.{method_name}"

if full_method_name in self._method_verbs:

# these are methods configured in the github/openapi.index.json file

known_verb = f'"{self._method_verbs[full_method_name]}"'

if known_verb != verb:

print(

f"Method {full_method_name} is known to call {known_verb}, "

f"but doc-string says {verb}"

)

else:

# detect method from code

visitor = FunctionCallCollector()

node.body.visit(visitor)

calls = visitor.calls

# calls to PaginatedList(...) are equivalent to

# self.__requester.requestJsonAndCheck("GET", …, parameters=…, headers=…)

calls = [

("self.__requester.requestJsonAndCheck", ['"GET"', "…", "parameters=…", "headers=…"])

if func in ["PaginatedList", "github.PaginatedList.PaginatedList"]

else (func, args)

for func, args in calls

]

# calls to self._requester.graphql_ are equivalent to

# self._requester.requestJsonAndCheck("POST", …, input=…)

calls = [

("self._requester.requestJsonAndCheck", ['"POST"', "…", "input=…"])

if func.startswith("self._requester.graphql_")

else (func, args)

for func, args in calls

]

# calls to github.AuthenticatedUser.AuthenticatedUser(self.__requester, url=url, completed=False)

# where class extends CompletableGithubObject are equivalent to

# self._requester.requestJsonAndCheck("GET", …, headers=…)

calls = [

(

"self._requester.requestJsonAndCheck",

['"GET"', "…", "headers=…"],

"CompletableGithubObject",

)

if func.startswith("github.")

and args

and args[0]

in [

"self._requester",

"self.__requester",

"requester=self._requester",

"requester=self.__requester",

]

and (

len(args) > 1

and args[1].startswith("url=")

or len(args) > 2

and args[2].startswith(('{"url":', 'attributes={"url":'))

)

else (func, args, None)

for func, args in calls

]

# skip functions that call into parent functions

if not any(func.startswith("super().") for func, args, base in calls):

# check for requester calls with the expected verb

if not any(

func.startswith(("self._requester.request", "self.__requester.request"))

and args

and args[0] == verb

for func, args, base in calls

):

print(f"Not found any {verb} call in {self.current_class_name}.{method_name}")

for func, args, base in calls:

print(f"- calls {func}({', '.join(args)})")

# else:

# # check if the found verb depends on a base class, which we cannot test here

# if not any(

# func.startswith(("self._requester.request", "self.__requester.request"))

# and args

# and args[0] == verb

# and base is None

# for func, args, base in calls

# ):

# print(

# f"Not found any {verb} call in {self.current_class_name}.{method_name} "

# f"conditional on some base class"

# )

# for func, args, base in calls:

# print(f"- calls {func}({', '.join(args)})")

if method_name == "__repr__":

# extract properties used here as ids

visitor = DictKeyCollector(self._ids)

def __init__(self, keys: list[str]):

super().__init__()

self.keys = keys

def visit_DictElement_key(self, node: cst.DictElement):

def __init__(

self,

module_name: str,

class_name: str,

properties: dict[str, (PythonType | GithubClass | None, bool)],

deprecate: bool,

):

super().__init__()

self.module_name = module_name

self.class_name = class_name

properties = [Property(name=n, data_type=t, deprecated=d) for n, (t, d) in properties.items()]

self.properties = sorted(properties, key=lambda p: p.name)

self.all_properties = self.properties.copy()

self.deprecate = deprecate

@property

def current_property(self) -> Property | None:

if not self.properties:

return None

def __init__(

self,

module_name: str,

class_name: str,

properties: dict[str, (PythonType | GithubClass | None, bool)],

completable: bool,

deprecate: bool,

):

super().__init__(module_name, class_name, properties, deprecate)

self.completable = completable

@staticmethod

def deprecate_function(node: cst.FunctionDef) -> cst.FunctionDef:

decorators = list(node.decorators)

decorators.append(cst.Decorator(decorator=cst.Name(value="deprecated")))

return node.with_changes(decorators=decorators)

def inner_github_type(self, data_type: PythonType | GithubClass | list[PythonType | GithubClass]) -> [GithubClass]:

if data_type is None:

return []

if isinstance(data_type, list):

return [ght for dt in data_type for ght in self.inner_github_type(dt)]

if isinstance(data_type, PythonType):

return self.inner_github_type(data_type.inner_types)

if isinstance(data_type, GithubClass):

return [data_type]

raise ValueError("Unsupported data type", data_type)

def leave_Module(self, original_node: Module, updated_node: Module) -> Module:

i = 0

node = updated_node

# add from __future__ import annotations if not the first import

node = self.add_future_import(node)

property_classes = {

ghc

for p in self.all_properties

for ghc in self.inner_github_type(p.data_type)

if ghc.module != self.module_name and ghc.name != self.class_name

}

import_classes = sorted(property_classes, key=lambda c: c.module)

typing_classes = sorted(property_classes, key=lambda c: c.module)

# TODO: do not import this file itself

datetime_exists = False

in_github_imports = False

needs_datetime_import = any(

p.data_type.type == "datetime" for p in self.all_properties if isinstance(p.data_type, PythonType)

)

# insert import classes if needed

while (

i < len(node.body)

and isinstance(node.body[i], cst.SimpleStatementLine)

and isinstance(node.body[i].body[0], (cst.Import, cst.ImportFrom))

):

if self.is_datetime_import(node.body[i].body[0]):

datetime_exists = True

if not in_github_imports and self.is_github_import(node.body[i].body[0]):

in_github_imports = True

# emit datetime import if needed

if needs_datetime_import and not datetime_exists:

node = self.add_datetime_import(node, i)

datetime_exists = True

i = i + 1

if in_github_imports and import_classes:

import_node = node.body[i].body[0]

imported_module = (

(

import_node.module.value

if isinstance(import_node.module, cst.Name)

else import_node.module.attr.value

)

if isinstance(import_node, cst.ImportFrom)

else import_node.names[0].name.attr.value

)

while import_classes and import_classes[0].module < imported_module:

import_module = import_classes.pop(0)

import_stmt = cst.SimpleStatementLine(

[

cst.Import(

[cst.ImportAlias(self.create_attribute([import_module.package, import_module.module]))]

)

]

)

stmts = node.body

node = node.with_changes(body=tuple(stmts[:i]) + (import_stmt,) + tuple(stmts[i:]))

if import_classes and import_classes[0].module == imported_module:

import_classes.pop(0)

i = i + 1

# emit datetime import if needed

if needs_datetime_import and not datetime_exists:

node = self.add_datetime_import(node, i)

i = i + 1

while import_classes:

import_module = import_classes.pop(0)

import_stmt = cst.SimpleStatementLine(

[cst.Import([cst.ImportAlias(self.create_attribute([import_module.package, import_module.module]))])]

)

stmts = node.body

node = node.with_changes(body=tuple(stmts[:i]) + (import_stmt,) + tuple(stmts[i:]))

# insert typing classes if needed

# find first If statement in node.body

if_idx_node_or_none = next(

((idx, stmt) for idx, stmt in enumerate(node.body) if isinstance(stmt, cst.If)), None

)

if if_idx_node_or_none is not None:

if_idx, if_node = if_idx_node_or_none

i = 0

while i < len(if_node.body.body) and isinstance(if_node.body.body[i].body[0], (cst.Import, cst.ImportFrom)):

imported_module = if_node.body.body[i].body[0].module.attr.value

while typing_classes and typing_classes[0].module < imported_module:

typing_class = typing_classes.pop(0)

import_stmt = cst.SimpleStatementLine(

[

cst.ImportFrom(

module=self.create_attribute([typing_class.package, typing_class.module]),

names=[cst.ImportAlias(cst.Name(typing_class.name))],

)

]

)

stmts = if_node.body.body

if_node = if_node.with_changes(

body=if_node.body.with_changes(body=tuple(stmts[:i]) + (import_stmt,) + tuple(stmts[i:]))

)

if typing_classes and typing_classes[0].module == imported_module:

typing_classes.pop(0)

i = i + 1

while typing_classes:

typing_class = typing_classes.pop(0)

import_stmt = cst.SimpleStatementLine(

[

cst.ImportFrom(

module=self.create_attribute([typing_class.package, typing_class.module]),

names=[cst.ImportAlias(cst.Name(typing_class.name))],

)

]

)

stmts = if_node.body.body

if_node = if_node.with_changes(

body=if_node.body.with_changes(body=tuple(stmts[:i]) + (import_stmt,) + tuple(stmts[i:]))

)

node = node.with_changes(body=tuple(node.body[:if_idx]) + (if_node,) + tuple(node.body[if_idx + 1 :]))

return node

def leave_FunctionDef(self, original_node: cst.FunctionDef, updated_node: cst.FunctionDef):

if self.current_class_name != self.class_name:

return updated_node

if updated_node.name.value.startswith("__") and updated_node.name.value.endswith("__"):

return updated_node

if updated_node.name.value == "_initAttributes":

return self.update_init_attrs(updated_node)

nodes = []

if updated_node.name.value == "_useAttributes":

while self.current_property:

prop = self.properties.pop(0)

node = self.create_property_function(prop.name, prop.data_type, prop.deprecated)

nodes.append(cst.EmptyLine(indent=False))

nodes.append(node)

nodes.append(self.update_use_attrs(updated_node))

return cst.FlattenSentinel(nodes=nodes)

updated_node_is_github_object_property = self.is_github_object_property(updated_node)

while self.current_property and (

updated_node_is_github_object_property

and self.current_property.name < updated_node.name.value