def test_title_case():
assert title_case('aCamelCasedString') == 'A Camel Cased String'
assert title_case('A_snake_cased_string') == 'A Snake Cased String'
assert title_case('A-kebab-cased-string') == 'A Kebab Cased String'
assert title_case('A normal sentence') == 'A Normal Sentence'
assert title_case('_an underscore-prefix') == 'An Underscore Prefix'
assert title_case('FoobarAPIController') == 'Foobar API Controller'
assert title_case('') == ''
assert title_case(None) is None
def handle_error(self, error, data):
"""
Customize the error messages for required/not-null validators with
dynamically generated field names. This is definitely a little hacky (it
mutates state, uses hardcoded strings), but unsure how better to do it
"""
required_messages = {
'Missing data for required field.', 'Field may not be null.'
}
for field_name in error.field_names:
for i, msg in enumerate(error.messages[field_name]):
if msg in required_messages:
label = title_case(field_name)
error.messages[field_name][i] = f'{label} is required.'
def process_objects(self, app: Flask, objects):
for name, serializer in objects.items():
self.bundle.serializers[name] = serializer
class_registry.register(name, serializer)
model = serializer.Meta.model
model_name = model if isinstance(model, str) else model.__name__
kind = getattr(serializer, '__kind__', 'all')
if kind == 'all':
self.bundle.serializers_by_model[model_name] = serializer
api.register_serializer(serializer, name=title_case(model_name))
elif kind == 'create':
self.bundle.create_by_model[model_name] = serializer
elif kind == 'many':
self.bundle.many_by_model[model_name] = serializer
def process_objects(
self,
app: FlaskUnchained,
serializers: Dict[str, Type[ModelSerializer]],
) -> None:
for name, serializer in serializers.items():
self.bundle.serializers[name] = serializer
model = serializer.Meta.model
model_name = model if isinstance(model, str) else model.__name__
kind = getattr(serializer, '__kind__', 'all')
if kind == 'all':
self.bundle.serializers_by_model[model_name] = serializer
api.register_serializer(serializer,
name=title_case(model_name))
elif kind == 'create':
self.bundle.create_by_model[model_name] = serializer
elif kind == 'many':
self.bundle.many_by_model[model_name] = serializer
def register_model_resource(self, resource: ModelResource):
"""
Method to manually register a :class:`ModelResource` with APISpec.
:param resource:
"""
model_name = resource.Meta.model.__name__
self.spec.add_tag({
'name': model_name,
'description': resource.Meta.model.__doc__,
})
for method in resource.methods():
key = f'{resource.__name__}.{method}'
if key not in unchained.controller_bundle.controller_endpoints:
continue
docs = {}
http_method = method
if method == CREATE:
http_method = 'post'
docs[http_method] = dict(
parameters=[{
'in': __location_map__['json'],
'required': True,
'schema': resource.Meta.serializer_create,
}],
responses={
'201':
dict(description=getattr(resource, CREATE).__doc__,
schema=resource.Meta.serializer_create),
},
)
elif method == DELETE:
docs[http_method] = dict(
parameters=[],
responses={
'204':
dict(description=getattr(resource, DELETE).__doc__),
},
)
elif method == GET:
docs[http_method] = dict(
parameters=[],
responses={
'200':
dict(description=getattr(resource, GET).__doc__,
schema=resource.Meta.serializer),
},
)
elif method == LIST:
http_method = 'get'
docs[http_method] = dict(
parameters=[],
responses={
'200':
dict(description=getattr(resource, LIST).__doc__,
schema=resource.Meta.serializer_many),
},
)
elif method == PATCH:
docs[http_method] = dict(
parameters=[{
'in': __location_map__['json'],
'required': False,
'schema': resource.Meta.serializer,
}],
responses={
'200':
dict(description=getattr(resource, PATCH).__doc__,
schema=resource.Meta.serializer),
},
)
elif method == PUT:
docs[http_method] = dict(
parameters=[{
'in': __location_map__['json'],
'required': True,
'schema': resource.Meta.serializer,
}],
responses={
'200':
dict(description=getattr(resource, PUT).__doc__,
schema=resource.Meta.serializer),
},
)
docs[http_method]['tags'] = [model_name]
display_name = title_case(model_name)
if method == LIST:
display_name = pluralize(display_name)
docs[http_method][
'summary'] = f'{http_method.upper()} {display_name}'
routes = unchained.controller_bundle.controller_endpoints[key]
for route in routes:
for rule in self.app.url_map.iter_rules(route.endpoint):
self.spec.add_path(app=self.app,
rule=rule,
operations=docs,
view=route.view_func)
def __plural_label__(self):
return title_case(pluralize(self.__name__))
def __label__(self):
return title_case(self.__name__)