def converts_typical_names():
assert snake_to_camel("snake_case") == "SnakeCase"
assert (
snake_to_camel("input_object_type_extension_node")
== "InputObjectTypeExtensionNode"
)
assert snake_to_camel("snake_to_camel") == "SnakeToCamel"
def args_to_camelcase(self, arguments):
if not isinstance(arguments, dict):
return
keys = [k for k in arguments.keys()]
for key in keys:
if isinstance(arguments[key], list):
for arg in arguments[key]:
self.args_to_camelcase(arg)
arguments[snake_to_camel(key, upper=False)] = arguments.pop(key)
def test_rename_visitor_type_coverage(self):
"""Check that all types are covered without overlap."""
type_sets = [
RenameSchemaTypesVisitor.noop_types,
RenameSchemaTypesVisitor.rename_types,
]
all_types = {snake_to_camel(node_type) + "Node" for node_type in QUERY_DOCUMENT_KEYS}
type_sets_union = set()
for type_set in type_sets:
self.assertTrue(type_sets_union.isdisjoint(type_set))
type_sets_union.update(type_set)
self.assertEqual(all_types, type_sets_union)
def __init__(
self,
name: str,
fields: Thunk[GraphQLInputFieldMap],
description: Optional[str] = None,
out_type: Optional[GraphQLInputFieldOutType] = None,
extensions: Optional[Dict[str, Any]] = None,
ast_node: Optional[InputObjectTypeDefinitionNode] = None,
extension_ast_nodes: Optional[Collection[InputObjectTypeExtensionNode]] = None,
) -> None:
fields = {snake_to_camel(k, False): v for k, v in fields.items()}
name = snake_to_camel(name)
super().__init__(
name,
fields,
description,
out_type,
extensions,
ast_node,
extension_ast_nodes,
)
def __init__(
self,
name: str,
fields: Thunk[GraphQLFieldMap],
interfaces: Optional[Thunk[Collection["GraphQLInterfaceType"]]] = None,
is_type_of: Optional[GraphQLIsTypeOfFn] = None,
extensions: Optional[Dict[str, Any]] = None,
description: Optional[str] = None,
ast_node: Optional[ObjectTypeDefinitionNode] = None,
extension_ast_nodes: Optional[Collection[ObjectTypeExtensionNode]] = None,
) -> None:
fields = {snake_to_camel(k, False): v for k, v in fields.items()}
name = snake_to_camel(name)
super().__init__(
name,
fields,
interfaces,
is_type_of,
extensions,
description,
ast_node,
extension_ast_nodes,
)
def arguments(self, definition: Optional[Dict]) -> Optional[GraphQLArgumentMap]:
result: GraphQLArgumentMap = dict()
if not definition or not isinstance(definition, (list, tuple)):
return None
for arg in definition:
if not isinstance(arg, (Argument, ArgumentList)):
continue
mapped_type = self.map_input(arg.type)
if arg.required:
mapped_type = graphql.GraphQLNonNull(mapped_type)
arg_name = snake_to_camel(arg.name, False) if self.camelcase else arg.name
result[arg_name] = graphql.GraphQLArgument(
mapped_type, description=arg.description
)
return result
def graphql_type(cls):
if hasattr(cls, "_graphql_type"):
return cls._graphql_type
fields = {}
public_attrs = ((attr_name, y)
for attr_name, y in cls.__annotations__.items()
if not attr_name.startswith("_"))
for attr_name, attr in public_attrs:
if attr_name.startswith("_"):
continue
field = InputField(python_type_to_graphql_type(attr))
field_name = snake_to_camel(attr_name, upper=False)
fields[field_name] = field
cls._graphql_type = cls.graphql_object_class(cls.__name__, fields)
return cls._graphql_type
def field_name(self, field: Field) -> str:
field_name = field.metadata.get("alias", field.name)
if self.camelcase:
field_name = snake_to_camel(field_name, upper=False)
return field_name
def may_start_with_uppercase():
result = snake_to_camel("Snake_case")
assert result == "SnakeCase"
def keeps_already_camel():
assert snake_to_camel("CamelCase") == "CamelCase"
def works_with_acronyms():
assert snake_to_camel("slow_xml_parser") == "SlowXmlParser"
assert snake_to_camel("fast_graph_ql_parser") == "FastGraphQlParser"
def graphql_type(cls):
if hasattr(cls, "_graphql_type"):
return cls._graphql_type
fields = {}
public_attrs = ((attr_name, y)
for attr_name, y in cls.__dict__.items()
if not attr_name.startswith("_"))
for attr_name, attr in public_attrs:
if attr_name.startswith("_"):
continue
signature = inspect.signature(attr)
params = list(signature.parameters.items())
# if params[0][0] != "data":
# raise Exception("1st parameter of function should be 'data'")
# if params[1][0] != "info":
# raise Exception("2nd parameter of function should be 'info'")
if not params:
raise Exception("First two args should be 'data' and 'info'")
arg_offset = 2
if len(params) < 2:
raise Exception("First two args should be 'data' and 'info'")
has_snake_case_args = any(
"_" in param_name for param_name, param in params[arg_offset:])
args = {
snake_to_camel(param_name, upper=False):
GraphQLArgument(python_type_to_graphql_type(param.annotation))
for param_name, param in params[arg_offset:]
}
try:
return_type = cls.__annotations__[attr_name].__args__[-1]
except (AttributeError, KeyError):
return_type = signature.return_annotation
# return_type = attr.__annotations__["return"]
# TODO: Need async version
def resolver_shim(func, data, info, *args, **kwargs):
kwargs = {camel_to_snake(k): v for k, v in kwargs.items()}
return func(data, info, *args, **kwargs)
if has_snake_case_args:
resolver = partial(resolver_shim, attr)
else:
resolver = attr
field = Field(python_type_to_graphql_type(return_type),
args=args,
resolve=resolver)
field_name = snake_to_camel(attr_name, upper=False)
fields[field_name] = field
cls._graphql_type = cls.graphql_object_class(cls.__name__, fields)
return cls._graphql_type
"id": 1,
"name": f"tag-{i}",
"count": i
} for i in range(i, 4)],
} for i in range(params.per_page)],
"page":
params.per_page,
"per_page":
params.per_page,
"total":
1,
}
TViewer = router.build_query("t_viewer")
QueryRootType = GraphQLObjectType(
name="QueryRoot",
fields={
"viewer":
GraphQLField(TViewer, resolve=lambda *_: TViewer),
snake_to_camel("health_check", False):
GraphQLField(type_=rs.String,
resolve=lambda *_: "schema load success"),
},
)
MutationRootType = router.build_mutation("mutation_root")
Schema = GraphQLSchema(QueryRootType, MutationRootType)
def keeps_already_camel():
result = snake_to_camel("CamelCase")
assert result == "CamelCase"
def works_with_acronyms():
result = snake_to_camel("slow_xml_parser")
assert result == "SlowXmlParser"
result = snake_to_camel("fast_graph_ql_parser")
assert result == "FastGraphQlParser"
def may_start_with_uppercase():
assert snake_to_camel("Snake_case") == "SnakeCase"
def converts_typical_names():
result = snake_to_camel('snake_case')
assert result == 'SnakeCase'
result = snake_to_camel('input_object_type_extension_node')
assert result == 'InputObjectTypeExtensionNode'
def works_with_numbers():
assert snake_to_camel("python3_script") == "Python3Script"
assert snake_to_camel("snake2camel") == "Snake2camel"
def may_start_with_uppercase():
result = snake_to_camel('Snake_case')
assert result == 'SnakeCase'
def can_produce_lower_camel_case():
assert snake_to_camel("snake_case", upper=False) == "snakeCase"
assert (
snake_to_camel("input_object_type_extension_node", False)
== "inputObjectTypeExtensionNode"
)
def works_with_acronyms():
result = snake_to_camel('slow_xml_parser')
assert result == 'SlowXmlParser'
result = snake_to_camel('fast_graph_ql_parser')
assert result == 'FastGraphQlParser'
def keeps_already_camel():
result = snake_to_camel('CamelCase')
assert result == 'CamelCase'
def can_produce_lower_camel_case():
result = snake_to_camel('snake_case', upper=False)
assert result == 'snakeCase'
result = snake_to_camel('input_object_type_extension_node', False)
assert result == 'inputObjectTypeExtensionNode'
def get_field(self, name):
if self.camelcase:
name = snake_to_camel(name, upper=False)
if name in self.type.fields:
return name, self.type.fields[name]
raise KeyError("Field {} doesnt exist in type {}.".format(name, self.type.name))
def converts_typical_names():
result = snake_to_camel("snake_case")
assert result == "SnakeCase"
result = snake_to_camel("input_object_type_extension_node")
assert result == "InputObjectTypeExtensionNode"
