Return pretty list description of parameter
488660
def pretty(self,verbose=0):
        """"""
        # split prompt lines and add blanks in later lines to align them
        plines = self.prompt.split('\n')
        for i in range(len(plines)-1): plines[i+1] = 32*' ' + plines[i+1]
        plines = '\n'.join(plines)
        namelen = min(len(self.name), 12)
        pvalue = self.get(prompt=0,lpar=1)
        alwaysquoted = ['s', 'f', '*gcur', '*imcur', '*ukey', 'pset']
        if self.type in alwaysquoted and self.value is not None: pvalue = '"' + pvalue + '"'
        if self.mode == "h":
            s = "%13s = %-15s %s" % ("("+self.name[:namelen],
                                    pvalue+")", plines)
        else:
            s = "%13s = %-15s %s" % (self.name[:namelen],
                                    pvalue, plines)
        if not verbose: return s

        if self.choice is not None:
            s = s + "\n" + 32*" " + "|"
            nline = 33
            for i in range(len(self.choice)):
                sch = str(self.choice[i]) + "|"
                s = s + sch
                nline = nline + len(sch) + 1
                if nline > 80:
                    s = s + "\n" + 32*" " + "|"
                    nline = 33
        elif self.min not in [None, INDEF] or self.max not in [None, INDEF]:
            s = s + "\n" + 32*" "
            if self.min not in [None, INDEF]:
                s = s + str(self.min) + " <= "
            s = s + self.name
            if self.max not in [None, INDEF]:
                s = s + " <= " + str(self.max)
        return s
121022
def _get_description(self, args: Tuple, kwargs: Dict[str, Any]) -> Dict[str, Any]:
        """"""
        return {
            'id': uuid1().hex,
            'args': args,
            'kwargs': kwargs,
            'module': self._module_name,
            'function': self.f.__name__,
            'sender_hostname': socket.gethostname(),
            'sender_pid': os.getpid(),
            'sender_cmd': ' '.join(sys.argv),
            'sender_timestamp': datetime.utcnow().isoformat()[:19],
        }
919914
function getIdlParameterList(parameters) {
    var result = []

    if (parameters.length == 0) return "";

    result.push("<table>")
    parameters.forEach(function(parameter, index, list){
        var comma = (index == list.length-1) ? "" : ","
        result.push("<tr>")
        result.push("<td>" + Indent2 + (parameter.out ? "out" : "in"))
        result.push("<td>" + getIdlType(parameter.type))
        result.push("<td>" + "<span class='parameterName tdIndent'>" + parameter.name + comma + "</span>")
    })

    result.push("</table>")
    return result.join("\n") + Indent
}
932207
def pretty(d, indent=0):
    
    for key, value in d.items():
        print('  ' * indent + str(key))
        if isinstance(value, dict):
            pretty(value, indent+1)
        else:
            sys.stderr.write('  ' * (indent+1) + str(value) + '\n')
22238
def p_define_params_paramlist(p):
    
    for i in p[2]:
        if not isinstance(i, ID):
            error(p.lineno(3),
                  '"%s" might not appear in a macro parameter list' % str(i))
            p[0] = None
            return

    names = [x.name for x in p[2]]
    for i in range(len(names)):
        if names[i] in names[i + 1:]:
            error(p.lineno(3),
                  'Duplicated name parameter "%s"' % (names[i]))
            p[0] = None
            return

    p[0] = p[2]
204322
def parameters_as_string(self):
        """"""
        params = ", ".join([ p.name for p in self.ordered_parameters ])
        return params
465911
def _getParameters(self):
        """"""
        param = self.query._getParameters()        
        sortingNames = []
        for outputCol in self.__columns:
            sort_dictionary={"field" : outputCol, "direction" : "ASC"}
            sortingNames.append(sort_dictionary)            
        param.update({'sort' : {"ordersList" : sortingNames}})
        return param
590613
function getJavaScriptParameterList(parameters, returnType) {
    var result = []

    result.push("<table>")
    parameters.forEach(function(parameter){
        result.push("<tr>")
        result.push("<td>" + Indent2 + "<span class='parameterName'>" + parameter.name + ",</span>")
        result.push("<td><span class='tdIndent'>// " + getIdlType(parameter.type) + "</span>")
    })

    result.push("<tr>")
    result.push("<td>" + Indent2 + "<span class='parameterName'>callback</span>")
    result.push("<td><span class='tdIndent'>// function(error, " + getIdlType(returnType) + ")</span>")

    result.push("</table>")
    return result.join("\n") + Indent
}
1107712
def pretty_str(self, indent=0):
        
        spaces = ' ' * indent
        condition = pretty_str(self.condition)
        v = self.declarations.pretty_str() if self.declarations else ''
        i = self.increment.pretty_str(indent=1) if self.increment else ''
        pretty = '{}for ({}; {}; {}):\n'.format(spaces, v, condition, i)
        pretty += self.body.pretty_str(indent=indent + 2)
        return pretty
512589
function getMethodParamHtml(name, param) {
    return [
        '<tr>',
            '<td>',
                name,
                param.required ?
                    '<span title="Required field" style="color:red;cursor:default">&nbsp;*</span>' : '',
            '</td>',
            '<td>', param.type || 'As is', '</td>',
            '<td>', param.description, '</td>',
        '</tr>'
    ].join('');
}
787168
def nice_display(item):
    """"""
    if hasattr(item, 'all'):  # RelatedManager: display a list
        return ', '.join(map(text_type, item.all()))
    return item
854720
def pretty(self):
        ""
        pretty_obj = OrderedDict()
        for key, value in sorted(iteritems(self.__dict__)):
            if value is None:
                pretty_obj[key] = None
            elif is_str_or_unicode(value):
                pretty_obj[key] = self.__dict__.get(key)
            elif isinstance(value, list):
                pretty_obj[key] = []
            elif isinstance(value, dict):
                pretty_obj[key] = {}
            else:
                pretty_obj[key] = unicode_value(value)
        return pretty_obj
539360
def parameter_list(data):
        
        items = []
        for item in data:
            param = Parameter(item['name'], item['value'])
            if 'meta' in item: param.meta = item['meta']
            items.append(param)
        return items
508077
def pretty(self, indent=1, debug=False):
        
        debug_details = ''
        if debug:
            debug_details += '<isliteral=%r, iscanonical=%r>' % (self.isliteral, self.iscanonical)
        if self.isliteral:
            pretty_literal = self.args[0].pretty(indent=0, debug=debug)
            return (' ' * indent) + '%s(%s%s)' % (self.__class__.__name__, debug_details, pretty_literal)
        else:
            return super(NOT, self).pretty(indent=indent, debug=debug)
1247815
def pretty_str(self, indent=0):
        
        spaces = ' ' * indent
        condition = pretty_str(self.condition)
        pretty = '{}if ({}):\n'.format(spaces, condition)
        pretty += self.body.pretty_str(indent=indent + 2)
        if self.else_body:
            pretty += '\n{}else:\n'.format(spaces)
            pretty += self.else_body.pretty_str(indent=indent + 2)
        return pretty
777931
def pretty_str(self, indent=0):
        
        indent = ' ' * indent
        values = '{{{}}}'.format(', '.join(map(pretty_str, self.value)))

        if self.parenthesis:
            return '{}({})'.format(indent, values)
        return '{}{}'.format(indent, values)
277243
function _prettyGraphSONString(ugly) {
        var lines = ugly.trim().split(require('os').EOL);
        var vertices = _.map(lines, function (line) { return _parseVertex(line); });
        vertices.sort(_compareById);
        // Compute the stable JSON.
        var stringifyOpts = {
            space: 2
        };
        var prettyString = jsonStableStringify(vertices, stringifyOpts) + '\n';
        return prettyString;
    }