def update_codegen_ignore(spec):
with io.open(CODEGEN_IGNORE_PATH) as f:
ignore_lines = set(f.read().splitlines())
import kubernetes
k8s_apis = dir(kubernetes.client.apis)
k8s_models = dir(kubernetes.client.models)
api_modules = set()
model_modules = set()
for path in list(spec['paths'].values()):
for op_name in list(path.keys()):
if op_name != 'parameters':
op = path[op_name]
for tag in op['tags']:
tag = '_'.join([string_utils.camel_case_to_snake(x) for x in tag.split('_')])
api_modules.add(tag + '_api')
for model in list(spec['definitions'].keys()):
module_name = '_'.join([string_utils.camel_case_to_snake(x) for x in model.split('.')])
model_modules.add(module_name)
for api_module in api_modules:
suffix = api_module.split('_')[-1]
if suffix in ['0', 'pre012'] or api_module in k8s_apis:
ignore_lines.add('client/apis/{}.py'.format(api_module))
for model_module in model_modules:
if model_module in k8s_models:
ignore_lines.add('client/models/{}.py'.format(model_module))
with io.open(CODEGEN_IGNORE_PATH, mode='w') as f:
f.write('\n'.join(sorted(ignore_lines)))
def test_cannot_handle_non_string_objects(self):
with self.assertRaises(TypeError) as raised:
# noinspection PyTypeChecker
camel_case_to_snake(None)
self.assertEqual(str(raised.exception), 'Expected "str", received "NoneType"')
with self.assertRaises(TypeError) as raised:
# noinspection PyTypeChecker
camel_case_to_snake(False)
self.assertEqual(str(raised.exception), 'Expected "str", received "bool"')
with self.assertRaises(TypeError) as raised:
# noinspection PyTypeChecker
camel_case_to_snake(0)
self.assertEqual(str(raised.exception), 'Expected "str", received "int"')
with self.assertRaises(TypeError) as raised:
# noinspection PyTypeChecker
camel_case_to_snake([])
self.assertEqual(str(raised.exception), 'Expected "str", received "list"')
with self.assertRaises(TypeError) as raised:
# noinspection PyTypeChecker
camel_case_to_snake({'a': 1})
self.assertEqual(str(raised.exception), 'Expected "str", received "dict"')
def index(request):
'''
Supports the index of a users account and the post for a single account
'''
user = request.user
if request.method == "POST":
if teller_permission(user):
data = decode_json_content(request.body)
data = {camel_case_to_snake(key): data[key] for key in data}
data["user_id"] = data["user"]
del data["user"]
data['creator'] = user
data['balance'] = float(data.get('balance', 0))
Account.objects.create(**data)
return JsonResponse({}, status=201)
else:
return JsonResponse({}, status=403)
if user.is_anonymous:
return JsonResponse([], status=200, safe=False)
serialized_q = serialize_accounts(
user.account_set.extra(select={
'lower_name': 'lower(name)'
}).order_by('lower_name').all())
return JsonResponse(serialized_q, status=200, safe=False)
def create_user(request):
"""
Creates a user based on a request
"""
try:
data = decode_json_content(request.body)
if "password2" in data:
del data["password2"]
data = {
camel_case_to_snake(key): data[key]
for key in data if data[key]
}
role = None
if data.get('role') and not manager_permission(request.user):
return JsonResponse({}, status=403)
elif data.get('role'):
role = data['role']
del data['role']
user = User.objects.create_user(**data)
if role in PERMISSION_CLASSES:
user.user_permissions.add(PERMISSION_CLASSES[role])
return JsonResponse({}, status=200)
except TypeError as e:
return JsonResponse({}, status=422)
def post(request):
user = request.user
if user.is_anonymous:
account_ids = []
else:
account_ids = user.account_set.values_list('id', flat=True)
data = decode_json_content(request.body)
data = {
camel_case_to_snake(key): data[key]
for key in data
}
data['creator'] = user
data['amount'] = float(data['amount'])
if "account_to" in data:
data["account_to_id"] = data["account_to"]
del data["account_to"]
if "account_from" in data:
data["account_from_id"] = data["account_from"]
del data["account_from"]
if (
teller_permission(user) or
(
data.get("transaction_type") == "transfer" and
int(data.get("account_to_id")) in account_ids and
int(data.get("account_from_id")) in account_ids
)
):
Transaction.objects.create(**data)
return JsonResponse({}, status=201)
else:
return JsonResponse({}, status=403)
def create_meta_table_data(engine, dataset_schema: DatasetSchema):
session = sessionmaker(bind=engine)()
ds_content = {
camel_case_to_snake(k): v
for k, v in dataset_schema.items() if k != "tables"
}
ds_content["contact_point"] = str(ds_content.get("contact_point", ""))
ds_transformer = transformer_factory(models.Dataset)
dataset = models.Dataset(**ds_transformer(ds_content))
session.add(dataset)
for table_data in dataset_schema["tables"]:
table_content = {
camel_case_to_snake(k): v
for k, v in table_data.items() if k != "schema"
}
table = models.Table(
**{
**table_content,
**{
f: table_data["schema"].get(f)
for f in ("required", "display")
},
})
table.dataset_id = dataset.id
session.add(table)
for field_name, field_value in table_data["schema"][
"properties"].items():
field_content = {
k.replace("$", ""): v
for k, v in field_value.items() if k not in {"$comment"}
}
field_content["name"] = field_name
try:
field = models.Field(**field_content)
except TypeError as e:
raise NotImplementedError(
f'Import failed: at "{field_name}": {field_value!r}:\n{e}'
) from e
field.table_id = table.id
field.dataset_id = dataset.id
session.add(field)
session.commit()
def get_base_model_name_snake(self, model_name):
"""
Return base model name with API version removed, and remainder converted to snake case
:param model_name: string
:return: string
"""
result = self.get_base_model_name(model_name)
return string_utils.camel_case_to_snake(result)
def __get_models_for_package(model_package, api_version, requested_models):
models = []
for model, model_class in inspect.getmembers(model_package):
if model == 'V1ProjectRequest':
continue
if 'kind' in dir(model_class) and ('metadata' in dir(model_class)
or 'spec' in dir(model_class)):
# models with a 'kind' are top-level objects that we care about
matches = VERSION_RX.match(model)
if not matches:
# exclude unversioned models
continue
model_api = matches.group(0)
base_model_name = model.replace(model_api, '')
model_name_snake = string_utils.camel_case_to_snake(
base_model_name).lower()
model_api_snake = string_utils.camel_case_to_snake(
model_api).lower()
if requested_models and \
base_model_name not in requested_models and \
model_name_snake not in requested_models:
continue
if api_version:
# only include models for the requested API version
if model_api == api_version.capitalize():
models.append({
'model': model,
'model_api': model_api,
'model_api_snake': model_api_snake,
'base_model_name': base_model_name,
'model_name_snake': model_name_snake
})
else:
models.append({
'model': model,
'model_api': model_api,
'model_api_snake': model_api_snake,
'base_model_name': base_model_name,
'model_name_snake': model_name_snake
})
return models
def add_labels_to_domain_ontology(dg: Graph, attr_str: str) -> Graph:
query_string = 'select * where {?x rdf:type ' + attr_str + ' }'
query_result = dg.query(query_string)
for row in query_result:
attr_uri = row[0]
if attr_uri.rfind('#') == -1:
attr_name = attr_uri[attr_uri.rfind('/') + 1:]
else:
attr_name = attr_uri[attr_uri.rfind('#') + 1:]
attr_name = string_utils.camel_case_to_snake(attr_name, ' ')
dg.add((URIRef(attr_uri), RDFS.label, Literal(attr_name)))
return dg
def __init__(self,
project_id,
table,
select=None,
where=None,
order_by=None,
limit=None,
offset=None,
as_list=False,
reidentify=False,
all_in=[],
*args,
**kwargs):
self.as_list = as_list
self.reidentify = reidentify
self._project_id = project_id
table = string_utils.camel_case_to_snake(table)
if type(select) is str:
query = "select %s from %s " % (select, table)
elif type(select) is list:
query = "select %s from %s " % (', '.join(select), table)
else:
query = "select * from %s " % table
if where:
if type(where) is dict:
where_clauses = []
for k, v in where.items():
if type(v) is str:
where_clauses.append("%s = '%s'" % (k, v))
else:
where_clauses.append("%s = %s" % (k, v))
query = query + "where " + " and ".join(where_clauses)
else:
query = query + "where %s " % where
if where and all_in:
query = query + "and person_id in " + '(' + ','.join(all_in) + ')'
elif all_in:
query = query + "where person_id in " + '(' + ','.join(
all_in) + ')'
if order_by:
query = query + " order by %s " % order_by
if limit and type(limit) in (str, int):
query = query + " limit %s " % limit
if offset and type(offset) in (str, int):
query = query + " offset %s " % offset
print(query)
self.query = query
def __init__(self, model, api_version):
self.model = model
self.api_version = api_version
self.module_name = '{}_{}_{}'.format(self.module_prefix, self.api_version.lower(),
string_utils.camel_case_to_snake(self.model))
self.module_file = self.module_name + '.yml'
try:
helper_class = self.helper_class
self.helper = helper_class(self.api_version, self.model, debug=True)
except KubernetesException:
raise
def update_codegen_ignore(spec, output_path):
import io
import os
import string_utils
import kubernetes
codegen_ignore_path = os.path.join(os.path.dirname(output_path),
'.swagger-codegen-ignore')
ignore_lines = set()
k8s_apis = dir(kubernetes.client.apis)
k8s_models = dir(kubernetes.client.models)
api_modules = set()
model_modules = set()
for path in list(spec['paths'].values()):
for op_name in list(path.keys()):
if op_name != 'parameters':
op = path[op_name]
for tag in op.get('tags', []):
tag = '_'.join([
string_utils.camel_case_to_snake(x)
for x in tag.split('_')
])
api_modules.add(tag + '_api')
for model in list(spec['definitions'].keys()):
module_name = '_'.join(
[string_utils.camel_case_to_snake(x) for x in model.split('.')])
model_modules.add(module_name)
for api_module in api_modules:
suffix = api_module.split('_')[-1]
if suffix in ['0', 'pre012'] or api_module in k8s_apis:
ignore_lines.add('client/apis/{}.py'.format(api_module))
print(
"Skipping generation of client/apis/{}.py".format(api_module))
else:
print("Not skipping generation of client/apis/{}.py".format(
api_module))
for model_module in model_modules:
if model_module in k8s_models:
ignore_lines.add('client/models/{}.py'.format(model_module))
print("Skipping generation of client/models/{}.py".format(
model_module))
else:
print("Not skipping generation of client/models/{}.py".format(
model_module))
for module in list(ignore_lines):
module_name = module.split('/')[-1].split('.')[0]
test_module_name = 'test_{}'.format(module_name)
docs_module_name = "".join(
map(lambda x: x.capitalize(), module_name.split('_')))
ignore_lines.add("test/{}.py".format(test_module_name))
ignore_lines.add('docs/{}.md'.format(docs_module_name))
print("Skipping generation of test/{}.py".format(test_module_name))
print("Skipping generation of docs/{}.md".format(docs_module_name))
ignore_lines = ignore_lines.union(DEFAULT_CODEGEN_IGNORE_LINES)
with open(codegen_ignore_path, 'w') as f:
f.write('\n'.join(sorted(ignore_lines)))
def attribute_to_snake(name):
""" Convert an object property name from camel to snake """
result = string_utils.camel_case_to_snake(name)
if result.endswith('_i_p'):
result = re.sub(r'_i_p$', '_ip', result)
return result
def test_returns_same_string_if_all_uppercase(self):
s = 'UPPERCASE'
self.assertEqual(camel_case_to_snake(s), s)
def test_returns_lowercase_string_for_single_word(self):
s = 'Hello'
self.assertEqual(camel_case_to_snake(s), s.lower())
def snake_case_model(model):
return '_'.join(
[string_utils.camel_case_to_snake(x) for x in model.split('.')])
def test_returns_words_divided_by_underscores_for_each_camel_word(self):
s = 'CamelCaseStringToTest'
self.assertEqual(camel_case_to_snake(s), 'camel_case_string_to_test')
def test_returns_words_divided_by_underscores_for_each_camel_word_even_for_articles(self):
s = 'ThisIsACamelStringTestB'
self.assertEqual(camel_case_to_snake(s), 'this_is_a_camel_string_test_b')
def test_returns_same_string_if_all_lowercase(self):
s = 'lower'
self.assertEqual(camel_case_to_snake(s), s)
def test_handles_acronyms_gracefully(self):
s = 'SPAAppsAreVeryPopularOnTheWEBToday'
self.assertEqual(camel_case_to_snake(s), 'spa_apps_are_very_popular_on_the_web_today')
def test_should_use_provided_separator(self):
s = 'CamelCaseString'
self.assertEqual(camel_case_to_snake(s, '_'), 'camel_case_string')
self.assertEqual(camel_case_to_snake(s, '||'), 'camel||case||string')
self.assertEqual(camel_case_to_snake(s, ' '), 'camel case string')
def test_should_return_same_string_if_contains_spaces(self):
s = 'This Is Not A Camel Case String! butThisOneIs'
self.assertEqual(camel_case_to_snake(s), s)
