The positional arguments that unpack something.

        :type: list(Starred)
507291
def starargs(self):
        
        args = self.args or []
        return [arg for arg in args if isinstance(arg, Starred)]
742090
def unpack(packed):
    
    func, args = serializer.loads(packed)
    result = func(*args)
    if isinstance(result, collections.Iterable):
        return list(result)
    return None
942246
def _array_star(args):
    
    fn, cls, genelist, kwargs = args
    return _array(fn, cls, genelist, **kwargs)
812371
def handle_unset_list(self, line: str, position: int, tokens: ParseResults) -> ParseResults:
        
        for key in tokens['values']:
            if key in {BEL_KEYWORD_EVIDENCE, BEL_KEYWORD_SUPPORT}:
                self.evidence = None
            else:
                self.validate_unset_command(line, position, key)
                del self.annotations[key]

        return tokens
75530
def flatten_list(l):
    
    if (l == []) or (l is None):
        return l
    if isinstance(l[0], list):
        return flatten_list(l[0]) + flatten_list(l[1:])
    return l[:1] + flatten_list(l[1:])
17094
def get_params(self, *args, **kwargs):
        '''
        
        '''
        kwargs.update(self._data)
        if args and kwargs:
            raise ValueError('Cannot mix positional and named parameters')
        if args:
            return list(args)
        else:
            return kwargs
1239926
def p_list0(p):
    ''''''
    parts = p[1]
    if len(parts) > 1 or p.slice[2].ttype != tokenizer.tokentype.NEWLINE:
        parts.append(ast.node(kind='operator', op=p[2], pos=p.lexspan(2)))
        p[0] = ast.node(kind='list', parts=parts, pos=_partsspan(parts))
    else:
        p[0] = parts[0]
337200
def _list(self, args):
        '''
        
        '''
        args.pop(0)
        command = args[0]
        if command == 'packages':
            self._list_packages(args)
        elif command == 'files':
            self._list_files(args)
        elif command == 'repos':
            self._repo_list(args)
        else:
            raise SPMInvocationError('Invalid list command \'{0}\''.format(command))
799240
def unpack_hyperopt_vals(vals):
    
    assert isinstance(vals, dict), "Parameter must be given as dict."
    ret = {}
    for k, v in list(vals.items()):
        try:
            ret[k] = v[0]
        except (TypeError, IndexError):
            ret[k] = v
    return ret
1309708
def _treat_star_format(self,arg_format_list,args):
        

        num_stars = len([a for a in arg_format_list if a == "*"])
        if num_stars > 0:

            # Make sure the repeated format argument only occurs once, is last,
            # and that there is at least one format in addition to it.
            if num_stars == 1 and arg_format_list[-1] == "*" and len(arg_format_list) > 1:

                # Trim * from end
                arg_format_list = arg_format_list[:-1]

                # If we need extra arguments...
                if len(arg_format_list) < len(args):
                    f = arg_format_list[-1]
                    len_diff = len(args) - len(arg_format_list)
                    tmp = list(arg_format_list)
                    tmp.extend([f for i in range(len_diff)])
                    arg_format_list = "".join(tmp)
            else:
                err = "'*' format must occur only once, be at end of string, and be preceded by at least one other format."
                raise ValueError(err)

        return arg_format_list
552819
def p_enum_list(self, p):
        ''''''
        if p[1] is None:
            p[0] = []
        elif len(p) == 4:
            p[1].append(p[3])
            p[0] = p[1]
        elif len(p) == 2:
            p[0] = [p[1]]
255994
def p_lconst_list(self, p):
        ''''''
        if len(p) == 4:
            p[1].append(p[3])
            p[0] = p[1]
        elif len(p) == 2:
            p[0] = [p[1]]
679266
def process_list_arg(arg):
    
    if isinstance(arg, list):
        return arg
    elif isinstance(arg, basestring):
        args = []
        for part in arg.split(","):
            args.append(part.strip())
        return args
1250246
def unpack(self, unpacker):
        

        (a, b, c, d) = unpacker.unpack_struct(_HHHH)

        self.inner_info_ref = a
        self.outer_info_ref = b
        self.name_ref = c
        self.access_flags = d
538270
def unpack(cls, msg, client, server, _):
        
        # Leading 4 bytes are reserved.
        num_of_cursor_ids, = _UNPACK_INT(msg[4:8])
        cursor_ids = []
        pos = 8
        for _ in range(num_of_cursor_ids):
            cursor_ids.append(_UNPACK_INT(msg[pos:pos + 4])[0])
            pos += 4
        return OpKillCursors(_client=client, cursor_ids=cursor_ids,
                             _server=server)
672644
def unpack_glist(glist_ptr, cffi_type, transfer_full=True):
    

    current = glist_ptr
    while current:
        yield ffi.cast(cffi_type, current.data)
        if transfer_full:
            free(current.data)
        current = current.next
    if transfer_full:
        lib.g_list_free(glist_ptr)
407184
def arg_list(self, ending_char=TokenTypes.RPAREN):
        
        args = []
        while not self.cur_token.type == ending_char:
            args.append(self.expression())
            if self.cur_token.type == TokenTypes.COMMA:
                self.eat(TokenTypes.COMMA)

        return args