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"