def _print_arguments()

in knack/help.py [0:0]

• 101 lines of code
• 25 McCabe index (conditional complexity)

    def _print_arguments(self, help_file):  # pylint: disable=too-many-statements

        LINE_FORMAT = '{name}{padding}{tags}{separator}{short_summary}'
        indent = 1
        self.max_line_len = 0

        if not help_file.parameters:
            _print_indent('None', indent)
            _print_indent('')
            return None

        def _build_tags_string(item):

            preview_info = getattr(item, 'preview_info', None)
            preview = preview_info.tag if preview_info else ''

            experimental_info = getattr(item, 'experimental_info', None)
            experimental = experimental_info.tag if experimental_info else ''

            deprecate_info = getattr(item, 'deprecate_info', None)
            deprecated = deprecate_info.tag if deprecate_info else ''

            required = REQUIRED_TAG if getattr(item, 'required', None) else ''
            tags = ' '.join([x for x in [str(deprecated), str(preview), str(experimental), required] if x])
            tags_len = sum([
                len(deprecated),
                len(preview),
                len(experimental),
                len(required),
                tags.count(' ')
            ])
            if not tags_len:
                tags = ''
            return tags, tags_len

        def _layout_items(items):

            layouts = []
            for c in sorted(items, key=_get_parameter_key):

                deprecate_info = getattr(c, 'deprecate_info', None)
                if deprecate_info and not deprecate_info.show_in_help():
                    continue

                tags, tags_len = _build_tags_string(c)
                short_summary = _build_short_summary(c)
                long_summary = _build_long_summary(c)
                line_len = _get_line_len(c.name, tags_len)
                layout = {
                    'name': c.name,
                    'tags': tags,
                    'separator': FIRST_LINE_PREFIX if short_summary else '',
                    'short_summary': short_summary,
                    'long_summary': long_summary,
                    'group_name': c.group_name,
                    'line_len': line_len
                }
                if line_len > self.max_line_len:
                    self.max_line_len = line_len
                layouts.append(layout)
            return layouts

        def _print_items(layouts):
            last_group_name = ''

            for layout in layouts:
                indent = 1
                if layout['group_name'] != last_group_name:
                    if layout['group_name']:
                        print('')
                        print(layout['group_name'])
                    last_group_name = layout['group_name']

                layout['padding'] = ' ' * _get_padding_len(self.max_line_len, layout)
                _print_indent(
                    LINE_FORMAT.format(**layout),
                    indent,
                    _get_hanging_indent(self.max_line_len, indent),
                    width=self.textwrap_width,
                )

                indent = 2
                long_summary = layout.get('long_summary', None)
                if long_summary:
                    _print_indent(long_summary, indent, width=self.textwrap_width)

            _print_indent('')

        def _build_short_summary(item):
            short_summary = item.short_summary
            possible_values_index = short_summary.find(' Possible values include')
            short_summary = short_summary[0:possible_values_index
                                          if possible_values_index >= 0 else len(short_summary)]
            short_summary += self._get_choices_defaults_sources_str(item)
            short_summary = short_summary.strip()
            return short_summary

        def _build_long_summary(item):
            lines = []
            if item.long_summary:
                lines.append(item.long_summary)
            deprecate_info = getattr(item, 'deprecate_info', None)
            if deprecate_info:
                lines.append(str(item.deprecate_info.message))
            preview_info = getattr(item, 'preview_info', None)
            if preview_info:
                lines.append(str(item.preview_info.message))
            experimental_info = getattr(item, 'experimental_info', None)
            if experimental_info:
                lines.append(str(item.experimental_info.message))
            return ' '.join(lines)

        group_registry = ArgumentGroupRegistry([p.group_name for p in help_file.parameters if p.group_name])

        def _get_parameter_key(parameter):
            return '{}{}{}'.format(group_registry.get_group_priority(parameter.group_name),
                                   str(not parameter.required),
                                   parameter.name)

        parameter_layouts = _layout_items(help_file.parameters)
        _print_items(parameter_layouts)

        return indent