def convert_to_snake_case(d): if isinstance(d, str): return convert_camel_case_to_snake(d) if isinstance(d, list): return [ convert_to_snake_case(i) if isinstance(i, dict) else i for i in d ] if isinstance(d, dict): converted = {} for k, v in d.items(): if isinstance(v, (dict, list)): v = convert_to_snake_case(v) converted[convert_camel_case_to_snake(k)] = v return converted return d
async def _resolve_fields(info, email, project_name): """Async resolve of fields.""" email_dict: dict = await _get_email(email) role_dict: dict = await _get_role(email, project_name) email: str = email_dict['email'] role: str = role_dict['role'] if project_name and role: if role == 'admin': has_access = has_access_to_project( email, project_name, role) else: has_access = user_domain.get_project_access( email, project_name) if not user_domain.get_data(email, 'email') or \ not has_access: raise UserNotFound() result = dict() tasks = list() for requested_field in info.field_nodes[0].selection_set.selections: snake_field = convert_camel_case_to_snake(requested_field.name.value) if snake_field.startswith('_'): continue resolver_func = getattr( sys.modules[__name__], f'_get_{snake_field}' ) future = asyncio.ensure_future(resolver_func(email, project_name)) tasks.append(future) tasks_result = await asyncio.gather(*tasks) for dict_result in tasks_result: result.update(dict_result) return result
async def _resolve_fields(info, project_name): """Async resolve fields.""" result = dict( repositories=list(), environments=list(), files=list() ) tasks = list() project_name = project_name.lower() project_exist = project_domain.get_attributes( project_name, ['project_name'] ) if not project_exist: raise InvalidProject for requested_field in info.field_nodes[0].selection_set.selections: snk_fld = convert_camel_case_to_snake(requested_field.name.value) if snk_fld.startswith('_'): continue resolver_func = getattr( sys.modules[__name__], f'_get_{snk_fld}' ) future = asyncio.ensure_future(resolver_func(project_name)) tasks.append(future) tasks_result = await asyncio.gather(*tasks) for dict_result in tasks_result: result.update(dict_result) return result
def __init__(self, data=None, *args, **kwargs): # TODO: convert back the field name in the errors to CamelCase # TODO: provide an escape hatch for more flexible renaming data = {convert_camel_case_to_snake(k): v for k, v in data.items()} super().__init__(data, *args, **kwargs) for field_name in self.base_fields.keys(): if field_name not in data.keys( ) and not self.fields[field_name].required: self.fields.pop(field_name)
def resolve_model_fields(self, model: Type[GraphQLModel], gql_type: Any, schema: GraphQLSchema) -> Dict[str, Any]: """Translate fields from a GraphQL type into pydantic ones. Args: gql_type (Any): GraphQL type on which to translate fields schema (GraphQLSchema): GraphQL schema Raises: PydanticBindError: Raised when a fields can't be translated Returns: Dict[str, Any]: A dict with pydantic field names as keys and pydantic fields as values. All field names are converted to snake_case """ pyd_fields = {} input_fields: List[str] = gql_type.fields.keys() if model.GraphQL.include is not None: input_fields = model.GraphQL.include if model.GraphQL.exclude: raise PydanticBindError( "You cannot use __include__ and __exclude__ on a GraphQLModel" ) for name in input_fields: if name not in model.GraphQL.exclude: try: field = gql_type.fields[name] except KeyError as error: raise PydanticBindError( f'field "{name}" does not exist on type {gql_type.name}' ) from error field_type, default_value = self.resolve_field_typing( field.type, schema) if model.GraphQL.fields and name in model.GraphQL.fields: field_type = model.GraphQL.fields[name] if field_type is None: raise PydanticBindError( f'Don\'t know how to map "{name}" field from GraphQL type {gql_type.name}' ) if default_value is None: field_type = Optional[field_type] # Convert names to snake case pyd_fields[convert_camel_case_to_snake(name)] = ( field_type, default_value, ) return pyd_fields
async def _resolve_fields(info): """Async resolve fields.""" result = dict() tasks = list() jwt_content = util.get_jwt_content(info.context) for requested_field in info.field_nodes[0].selection_set.selections: snake_field = convert_camel_case_to_snake(requested_field.name.value) if snake_field.startswith('_'): continue resolver_func = getattr( sys.modules[__name__], f'_get_{snake_field}' ) future = asyncio.ensure_future(resolver_func(jwt_content)) tasks.append(future) tasks_result = await asyncio.gather(*tasks) for dict_result in tasks_result: result.update(dict_result) return result
def _columns_for_graphql_selection(info: GraphQLResolveInfo) -> Set[str]: """ Based on the selected GraphQL fields, determine which database columns should be retrieved. """ # Some columns are always retrieved columns = {'object_class', 'source', 'parsed_data', 'rpsl_pk'} fields = _collect_predicate_names( info.field_nodes[0].selection_set.selections) # type: ignore requested_fields = {ariadne.convert_camel_case_to_snake(f) for f in fields} for field in requested_fields: if field in RPSLDatabaseQuery().columns: columns.add(field) if field == 'asn': columns.add('asn_first') columns.add('asn_last') if field == 'prefix': columns.add('ip_first') columns.add('prefix_length') return columns
def test_two_words_snake_case_name_is_not_changed(): test_str = "test_name" assert convert_camel_case_to_snake(test_str) == test_str
def test_three_words_camel_case_name_is_converted(): assert convert_camel_case_to_snake( "testComplexName") == "test_complex_name"
def test_lower_case_name_is_not_changed(): test_str = "test" assert convert_camel_case_to_snake(test_str) == test_str
def test_two_words_camel_case_name_is_converted(): assert convert_camel_case_to_snake("testName") == "test_name"
def test_pascal_case_name_is_lowercased(): assert convert_camel_case_to_snake("Test") == "test"
def test_no_underscore_added_if_previous_character_is_uppercase(): assert convert_camel_case_to_snake("testWithUPPERPart") == "test_with_upperpart"
def test_no_underscore_added_if_previous_character_is_an_underscore(): assert convert_camel_case_to_snake("test__complexName") == "test__complex_name"
def test_digits_are_treated_as_word(test_str, result): assert convert_camel_case_to_snake(test_str) == result