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
