"""

        Builds API data with given random ID

        :param random_id:

        :type random_id:

        """

        return {

            "id": random_id,

            "api_key": apikey,

            "method": method,

            "args": kw

        }

    if not method:

        raise Exception('please specify method name !')

    id_ = random.randrange(1, 9999)

    req = urllib2.Request('%s/_admin/api' % apihost,

                      data=json.dumps(_build_data(id_)),

                      headers={'content-type': 'text/plain'})

    if format == FORMAT_PRETTY:

        sys.stdout.write('calling %s to %s \n' % (req.get_data(), apihost))

    ret = urllib2.urlopen(req)

    raw_json = ret.read()

    json_data = json.loads(raw_json)

    id_ret = json_data['id']

    _formatted_json = pprint.pformat(json_data)

    if id_ret == id_:

        if format == FORMAT_JSON:

            sys.stdout.write(str(raw_json))

        else:

            sys.stdout.write('rhodecode returned:\n%s\n' % (_formatted_json))

    else:

        raise Exception('something went wrong. '

                        'ID mismatch got %s, expected %s | %s' % (

                                            id_ret, id_, _formatted_json))

def argparser(argv):

    usage = ("rhodecode_api [-h] [--format=FORMAT] [--apikey=APIKEY] [--apihost=APIHOST] "

             "_create_config or METHOD <key:val> <key2:val> ...")

    parser = argparse.ArgumentParser(description='RhodeCode API cli',

                                     usage=usage)

    ## config

    group = parser.add_argument_group('config')

    group.add_argument('--apikey', help='api access key')

    group.add_argument('--apihost', help='api host')

    group = parser.add_argument_group('API')

    group.add_argument('method', metavar='METHOD', type=str,

            help='API method name to call followed by key:value attributes',

    )

    group.add_argument('--format', dest='format', type=str,

            help='output format default: `pretty` can '

                 'be also `%s`' % FORMAT_JSON,

            default=FORMAT_PRETTY

    )

    args, other = parser.parse_known_args()

    return parser, args, other

def main(argv=None):

    """

    Main execution function for cli

    :param argv:

    :type argv:

    """

    if argv is None:

        argv = sys.argv

    conf = None

    parser, args, other = argparser(argv)

    api_credentials_given = (args.apikey and args.apihost)

    if args.method == '_create_config':

        if not api_credentials_given:

            raise parser.error('_create_config requires --apikey and --apihost')

        conf = RcConf(autocreate=True, config={'apikey': args.apikey,

                                               'apihost': args.apihost})

        sys.stdout.write('Create new config in %s\n' % CONFIG_NAME)

    if not conf:

        conf = RcConf(autoload=True)

        if not conf:

            if not api_credentials_given:

                parser.error('Could not find config file and missing '

                             '--apikey or --apihost in params')

    apikey = args.apikey or conf['apikey']

    host = args.apihost or conf['apihost']

    method = args.method

    if method == '_create_config':

        sys.exit()

    api_call(apikey, host, args.format, method, **margs)

    return 0

if __name__ == '__main__':

    sys.exit(main(sys.argv))