def process(
self,
node: NodeType,
codegen: BaseCodegen,
flags: Set[BaseMiddlewareFlag],
) -> Optional[BaseIdentifier]:
if not isinstance(node, ClassFound):
return None
src_module_path = from_class_found(node)
generated_module_path = get_generated_module_path(
root_module_path=self.root_module_path,
src_module_path=src_module_path,
)
generated_file = get_generated_file(
generated_file_pool=self.generated_file_pool,
module_path=generated_module_path,
)
generated_file.add_import(src_module_path)
to_original_type_codegen = ToOriginalObjCodegen(
get_original_obj_ident(node)
)
from_original_type_codegen = FromOriginalObjCodegen()
graphene_fields_def_codegen = GrapheneFieldsDefCodegen()
for key,field_node in node.fields.items():
field_identifier = codegen._process(field_node, flags)
process_import(
generated_file=generated_file,
identifier=field_identifier,
)
to_original_type_codegen.add_field(
name=key,
identifier=field_identifier,
)
from_original_type_codegen.add_field(
name=key,
identifier=field_identifier,
)
graphene_fields_def_codegen.add_field(
name=key,
identifier=field_identifier,
)
# TODO: resolvers
# resolvers
# resolvers = process_resolver_funcs(typeor_node.methods)
generated_file.add_code(strip_margin(f"""
|class {node.name}(graphene.ObjectType):
|{textwrap.indent(graphene_fields_def_codegen.generate_code(), ' ')}
|{textwrap.indent(to_original_type_codegen.print_code(), ' ')}
|{textwrap.indent(from_original_type_codegen.print_code(), ' ')}
| ... # in case the object is empty
|"""))
return GeneratedGrapheneObjectIdentifier(
module=generated_module_path,
name=node.name
)
def get_resolver_fn_impl_code(
resolver_name: str,
return_ident: BaseIdentifier,
args_idents: Dict[str, BaseIdentifier],
):
arg_names = '\n'.join([f'{arg_name},' for arg_name in args_idents.keys()])
arg_names_assignments = '\n'.join(
[f'{arg_name}={arg_name}' for arg_name in args_idents.keys()])
# _from_original for return_ident...
return_value_code_str = gen_field_convertor_code(
field_code_str='result_original',
field_ident=return_ident,
func_str='_from_original',
)
return strip_margin(f"""
|def resolve_{resolver_name}(
| self, info,
|{textwrap.indent(arg_names, ' ' * 8)}
|):
| original = self._to_original()
| context = info.context
| result_original = original.resolve_{resolver_name}(
| context=context,
|{textwrap.indent(arg_names_assignments, ' ' * 8)}
| )
| return {return_value_code_str}
|""")
def graphene_field_code_from_args_and_output(
args_idents: Dict[str, PossibleIdentifiers],
return_ident: PossibleIdentifiers,
_g: str = 'graphene',
) -> str:
args_codes = {
arg_name: strip_margin(f'''{_g}.Argument(
| type_={identifier_to_graphene_typ(arg_ident)},
|)''')
for arg_name, arg_ident in args_idents.items()
}
args_code_str = '\n'.join([
f"'{arg_name}': {arg_code},"
for arg_name, arg_code in args_codes.items()
])
return_code_str = identifier_to_graphene_typ(return_ident)
return strip_margin(f'''graphene.Field(
| type_={return_code_str},
| args={{
|{textwrap.indent(args_code_str, ' ')}
| }}
|)
|''')
def print_code(self):
body = '\n'.join([
f'{key}={value},'
for key, value in self.field_codestring_map.items()
])
# TODO: maybe use something else below?
original_typ_name = f'{self.original_type_identifier.module}.{self.original_type_identifier.name}'
func_string = strip_margin(f"""
|def _to_original(self):
| return {original_typ_name}(
|{textwrap.indent(body, ' ' * 8)}
| )
|""")
return func_string
def write_generated_file(
generated: GeneratedFile,
root_folder: pathlib.Path,
):
module_path = generated.module_path.replace('.', sep)
module_folder = root_folder / module_path
print('module_folder:', module_folder)
module_folder.mkdir(parents=True, exist_ok=True)
filename = module_folder.joinpath('__init__.py').absolute()
code = strip_margin(f"""
|{imports_to_code(generated)}
|
|{generated.code}
|""")
with open(filename, 'w') as f:
f.write(code)
def print_code(self):
body = '\n'.join([
f'{key}={value},'
for key, value
in self.field_codestring_map.items()
])
func_string = strip_margin(f"""
|@classmethod
|def _from_original(cls, {self._orig}):
| return cls(
|{textwrap.indent(
body,
' ' * 8,
)}
| )
""")
return func_string
def process(
self,
node: NodeType,
codegen: BaseCodegen,
flags: Set[BaseMiddlewareFlag],
) -> Optional[PossibleIdentifiers]:
if not isinstance(node, TypeOR) \
or not flags.__contains__(is_output) \
or flags.__contains__(is_input):
return None
if is_optional_typeor(node):
raise RuntimeError('got Optional[A] in output_union_middleware',
node)
idents = [codegen._process(i, flags=flags) for i in node.nodes]
for n in idents:
process_import(
generated_file=self.to_write_file,
identifier=n,
)
# heck ugly but really un-likely to overlap?
union_name = '__UNION_WITH__'.join(
[ident_to_valid_python_name(ident) for ident in idents])
idents_meta_types_code = '\n'.join(
[f'{identifier_to_graphene_typ(a)},' for a in idents])
code_to_write = strip_margin(f"""
|class {union_name}(graphene.Union):
| class Meta:
| types = (
|{textwrap.indent(idents_meta_types_code, ' ' * 12)}
| )
|
|""")
self.to_write_file.add_code(code_to_write)
return GeneratedGrapheneObjectIdentifier(
module=self.to_write_module,
name=union_name,
)
def process(
self,
node: NodeType,
codegen: BaseCodegen,
flags: Set[BaseMiddlewareFlag],
) -> Optional[BaseIdentifier]:
if not isinstance(node, ClassFound):
return None
if not node.options.__contains__(is_query_flag):
return None
# must be query!
src_module_path = from_class_found(node)
generated_module_path = get_generated_module_path(
root_module_path=self.root_module_path,
src_module_path=src_module_path,
)
generated_file = get_generated_file(
generated_file_pool=self.generated_file_pool,
module_path=generated_module_path,
)
generated_file.add_import(src_module_path)
to_original_type_codegen = ToOriginalObjCodegen(
get_original_obj_ident(node)
)
from_original_type_codegen = FromOriginalObjCodegen()
graphene_fields_def_codegen = GrapheneFieldsDefCodegen()
input_flags = flags | {is_input}
output_flags = flags | {is_output}
for key, field_node in node.fields.items():
field_identifier = codegen._process(
field_node, flags=output_flags,
)
process_import(
generated_file=generated_file,
identifier=field_identifier,
)
to_original_type_codegen.add_field(
name=key,
identifier=field_identifier,
)
from_original_type_codegen.add_field(
name=key,
identifier=field_identifier,
)
graphene_fields_def_codegen.add_field(
name=key,
identifier=field_identifier,
)
resolver_func_codegen = ResolverFuncCodegen()
resolvers_raw = get_raw_resolvers(node.methods)
for name, raw_resolver in resolvers_raw.items():
args_idents: Dict[str, PossibleIdentifiers] = {
args_name: codegen._process(
node=args_node,
flags=input_flags,
)
for args_name, args_node in raw_resolver.params.items()
}
return_ident = codegen._process(
node=raw_resolver.return_type,
flags=output_flags,
)
resolver_func_codegen.add_resolver(
name=name,
args_idents=args_idents,
return_ident=return_ident,
)
class_body = strip_margin(f"""
|{graphene_fields_def_codegen.generate_code()}
|
|{to_original_type_codegen.print_code()}
|
|{from_original_type_codegen.print_code()}
|
|{resolver_func_codegen.print_code()}
|
|...
""")
generated_file.add_code(
strip_margin(f"""
|# from query_middleware
|class {node.name}(graphene.ObjectType):
|{textwrap.indent(class_body, ' ')}
|
""")
)
return GeneratedGrapheneObjectIdentifier(
module=generated_module_path,
name=node.name,
)