Return formatted assistants from the given list in human readable form.
170464
def format_assistants_lines(cls, assistants):
        ''''''
        lines = cls._format_files(assistants, 'assistants')

        # Assistant help
        if assistants:
            lines.append('')
            assistant = strip_prefix(random.choice(assistants), 'assistants').replace(os.path.sep, ' ').strip()
            if len(assistants) == 1:
                strings = ['After you install this DAP, you can find help about the Assistant',
                           'by running "da {a} -h" .']
            else:
                strings = ['After you install this DAP, you can find help, for example about the Assistant',
                           '"{a}", by running "da {a} -h".']
            lines.extend([l.format(a=assistant) for l in strings])

        return lines
1041765
def _bse_cli_list_formats(args):
    ''''''
    all_formats = api.get_formats()

    if args.no_description:
        liststr = all_formats.keys()
    else:
        liststr = format_columns(all_formats.items())

    return '\n'.join(liststr)
367659
def fromlist(cls, rnglist, autostep=None):
        """"""
        inst = RangeSet(autostep=autostep)
        inst.updaten(rnglist)
        return inst
196298
def format_items(self, data, many):
        
        if many:
            return [self.format_item(item) for item in data]
        else:
            return self.format_item(data)
214538
def _format_list(self, data):
        
        dataset = "["
        i = 0
        for el in data:
            if pd.isnull(el):
                dataset += "null"
            else:
                dtype = type(data[i])
                if dtype == int or dtype == float:
                    dataset += str(el)
                else:
                    dataset += '"' + el + '"'
            if i < len(data) - 1:
                dataset += ', '
        dataset += "]"
        return dataset
991787
def trunc_list(s: List) -> List:
    """"""
    if len(s) > max_list_size:
        i = max_list_size // 2
        j = i - 1
        s = s[:i] + [ELLIPSIS] + s[-j:]
    return s
943962
def format_result(input):
        
        items = list(iteritems(input))
        return OrderedDict(sorted(items, key=lambda x: x[0]))
1286943
def cmd_list(args):
    """"""
    for penlist in penStore.data:
        puts(penlist + " (" + str(len(penStore.data[penlist])) + ")")
1028450
def flat_list(input_list):
    

    """
    x = input_list
    if isinstance(x, list):
        return [a for i in x for a in flat_list(i)]
    else:
        return [x]
571531
def format_records(records):
    """"""
    formatted = list()
    for record_ in records:
        formatted.append(format_record(record_))
    return formatted
657064
def to_list(stringlist, unquote=True):
    """"""
    stringlist = stringlist[1:-1]
    return [
        string.strip('"') if unquote else string
        for string in stringlist.split(",")
    ]
134115
def list_input(*args, **kwargs):
    '''
    
    '''
    list_input = wtforms.TextAreaField(*args, **kwargs)
    list_input.input_type = 'list'
    return list_input
552948
def normalize(self, text, cleaned=False, **kwargs):
        """"""
        if not cleaned:
            text = self.clean(text, **kwargs)
        return ensure_list(text)
961391
def split_by_list(self, train, valid):
        ""
        return self._split(self.path, train, valid)
1244012
def parse_list(self, entries):
        """"""
        result_entries = SearchableList()
        for entry in entries:
            result_entries.append(self.instance.parse(self.requester, entry))
        return result_entries
1276195
def abbreviate_list(items, max_items=10, item_max_len=40, joiner=", ", indicator="..."):
  
  if not items:
    return items
  else:
    shortened = [abbreviate_str("%s" % item, max_len=item_max_len) for item in items[0:max_items]]
    if len(items) > max_items:
      shortened.append(indicator)
    return joiner.join(shortened)
416307
def _humanSortKey(s):
  """"""
  if isinstance(s, str):
    return [w.isdigit() and int(w) or w for w in re.split(r'(\d+)', s)]
  else:
    return s