def get_description(self, path: _t.Text, method: _t.Text) -> _t.Text:
# pylint: disable=simplifiable-if-statement,redefined-outer-name
method_name: _t.Text = getattr(self.view, 'action', method.lower())
method_obj: _t.Optional[_t.Callable] = getattr(self.view, method_name, None)
method_view: _t.Optional[_t.Type[rvs.APIView]] = (
getattr(method_obj, '_nested_view', None)
if method_obj else None
)
if method_obj.__doc__:
return method_obj.__doc__.strip()
if not method_view:
return super().get_description(path, method)
method_view_obj = method_view()
action = path.split('/')[-2]
submethod = getattr(method_view, action, None)
if submethod.__doc__:
return str(submethod.__doc__).strip() # nocv
if method == 'GET' and '{' not in path[:-1].split('/')[-1]:
action = 'list'
elif method == 'POST':
action = 'create'
elif method == 'GET':
action = 'retrieve'
elif method == 'PUT':
action = 'update'
elif method == 'PATCH':
action = 'partial_update'
elif method == 'DELETE':
action = 'destroy'
method_view_obj.action = action # type: ignore
if method_view_obj.schema is None:
return 'No description' # nocv
return method_view_obj.schema.get_description(path, method) # type: ignore
def parse_image_path(image_path: t.Text,
prefix: t.Optional[t.Text] = None) -> DockerImage:
""" Split benchmark image into name and tag, verify image path points to a valid directory.
Args:
image_path: Image path provided by a user, e.g., tensorrt/21.08.
prefix: Image prefix to use.
Returns:
A structure that provides docker image information (prefix, name and tag).
"""
parts = image_path.split(os.path.sep)
if len(parts) == 3 and (parts[2] == 'Dockerfile' or parts[2] == ''):
del parts[2]
if len(parts) != 2:
raise ValueError(
f"Invalid image path ({image_path}). Expecting FRAMEWORK/VERSION."
)
full_path = os.path.join(os.path.dirname(__file__), image_path)
if not os.path.isdir(full_path):
raise ValueError(
f"Invalid image path ({image_path}). Not a directory: {full_path}."
)
if not os.path.isfile(os.path.join(full_path, 'Dockerfile')):
raise ValueError(
f"Invalid image path ({image_path}). Not a file: {os.path.join(full_path, 'Dockerfile')}."
)
return DockerImage(prefix, parts[0], parts[1])
def _format_spaces(value: typing.Text, context: types.Context):
"The string is long, try to break it on spaces. And newlines."
# Break up the content on spaces but retain the
# spaces so we can also break on newlines
words = value.split(" ")
for i in range(len(words) - 1):
words[i] = words[i] + " "
# For each word see if we can make a line. Once it's
# too long we step back and add the line to our results.
results = []
line = []
while words:
word = words.pop(0)
# If the line has a newline then gather all the newlines
# together into a single line and break there.
newlines_start = word.find("\n")
newlines_end = newlines_start
if newlines_start > -1:
while newlines_end < len(word) and word[newlines_end] == "\n" :
newlines_end += 1
# Whatever is left that is not a newline needs to
# be added back to our stack for processing.
remainder = word[newlines_end:]
if remainder:
words.insert(0, remainder)
word = word[:newlines_end]
word = word.replace("\n", r"\n")
results.append(_make_string_line(line + [word], context.override(indent=0)))
line = []
continue
possible_line = line + [word]
test_line = _make_string_line(possible_line, context)
if len(test_line) < context.max_line_length:
line = possible_line
continue
results.append(_make_string_line(line, context.override(indent=0)))
line = []
words.insert(0, word)
if line:
results.append(_make_string_line(line, context.override(indent=0)))
content = "\n".join(results)
return "(\n" + content + "\n)"
return "{quote}{result}{quote}".format(
quote=context.quote,
result=result,
)
def add_indent_string(self, text: typing.Text) -> typing.Text:
"""Indent a string, if it has newlines.
This will take a string of the form "(\nfoo,\nbar,\n)"
and return a string of the form "(\n\tfoo,\n\tbar,\n\t).
In other words, it will indent all lines but the first.
This will not indent beyond the current context's indentation
level.
"""
lines = text.split("\n")
if len(lines) == 1:
return text
indented = []
max_tab = self.tab * self.indent
for line in lines[1:]:
if line.startswith(max_tab):
indented.append(line)
else:
indented.append(self.tab + line)
return lines[0] + "\n" + ("\n".join(indented))
def get_view(self, name: _t.Text, **options):
# pylint: disable=redefined-outer-name,too-many-statements
mixin_class: _t.Type[NestedViewMixin] = NestedViewMixin
if hasattr(self.view, 'create'):
if self.kwargs.get('allow_append', False):
mixin_class = NestedWithAppendMixin
else:
mixin_class = NestedWithoutAppendMixin
tp = name.split('_')[-1]
if tp == 'detail':
detail = True
elif tp == 'list':
detail = False
else:
detail = getattr(self.view, options['nested_sub']).detail
manager_name = self.kwargs.get('manager_name', self.name)
view_class = utils.get_if_lazy(self.view)
class NestedView(mixin_class, view_class): # type: ignore
__slots__ = ('nested_detail', ) # pylint: disable=class-variable-slots-conflict
__doc__ = self.view.__doc__
format_kwarg = None
queryset_filters = self.queryset_filters
NestedView.__name__ = self.view.__name__ # type: ignore
NestedView.nested_detail = detail # type: ignore
def nested_view_function_wrapper(view_obj, request, *args, **kwargs):
kwargs.update(options)
view_obj.nested_parent_object = view_obj.get_object()
nested_append_arg = view_obj.nested_append_arg
nested_request_arg = view_obj.nested_arg
nested_parent_object = view_obj.nested_parent_object
if nested_append_arg:
nested_id = getattr(nested_parent_object, nested_append_arg,
None)
else:
nested_id = None
if callable(manager_name):
nested_manager = manager_name(nested_parent_object)
else:
if hasattr(nested_parent_object, manager_name):
nested_manager = getattr(nested_parent_object,
manager_name)
else:
view_manager_function_name = f'get_manager_{manager_name}'
nested_manager_func = getattr(view_obj,
view_manager_function_name)
nested_manager = nested_manager_func(nested_parent_object)
NestedView.__name__ = self.view.__name__
NestedView.master_view = view_obj
NestedView.lookup_field = nested_append_arg
NestedView.lookup_url_kwarg = nested_request_arg
NestedView.nested_detail = detail
NestedView.nested_allow_append = view_obj.nested_allow_append
NestedView.nested_append_arg = nested_append_arg
NestedView.nested_request_arg = nested_request_arg
NestedView.nested_parent_object = nested_parent_object
NestedView.nested_id = nested_id
NestedView.nested_manager = nested_manager
getattr(view_obj, 'nested_allow_check',
lambda *args, **kwargs: None)()
return nested_view_function(view_obj, NestedView, request, *args,
**kwargs)
nested_view_function_wrapper.__name__ = name
nested_view_function_wrapper.__doc__ = self.view.__doc__
nested_view_function_wrapper._nested_view = self.view # type: ignore
nested_view_function_wrapper._nested_wrapped_view = NestedView # type: ignore
return name, nested_view_function_wrapper
def recursive_getattr(obj: typing.Any, attributes: typing.Text) -> typing.Any:
return functools.reduce(getattr, [obj] + attributes.split("."))
def parse_resolution(string: typing.Text) -> typing.Tuple[int, int]:
[width, height] = string.split('x')
return (int(width), int(height))
