"""calculate bootstrap bounds on a sample game"""
import argparse
import json
import sys

import numpy as np

from gameanalysis import bootstrap
from gameanalysis import gameio
from gameanalysis import regret
from gameanalysis import scriptutils


CHOICES = {
    'regret': (bootstrap.mixture_regret, regret.mixture_regret),
    'surplus': (bootstrap.mixture_welfare, regret.mixed_social_welfare),
}


[docs]def add_parser(subparsers):
    parser = subparsers.add_parser(
        'sgboot', help="""Bootstrap on sample games""", description="""Compute
        bootstrap statistics using a sample game with data for every profile in
        the support of the subgame and potentially deviations. The return value
        is a list with an entry for each mixture in order. Each element is a
        dictionary mapping percentile to value.""")
    parser.add_argument(
        '--input', '-i', metavar='<input-file>', default=sys.stdin,
        type=argparse.FileType('r'), help="""Input sample game to run bootstrap
        on.  (default: stdin)""")
    parser.add_argument(
        '--output', '-o', metavar='<output-file>', default=sys.stdout,
        type=argparse.FileType('w'), help="""Output file for script. (default:
        stdout)""")
    parser.add_argument(
        'profiles', metavar='<profile>', nargs='+', help="""File or string with
        profiles from input game for which regrets should be calculated.  This
        file can be a list or a single profile""")
    parser.add_argument(
        '-t', '--type', default='regret', choices=CHOICES, help="""What to
        return. regret - returns the regret of each profile. surplus - returns
        the bootstrap surplus of every profile.  (default: %(default)s)""")
    parser.add_argument(
        '--processes', metavar='num-processes', type=int, help="""The number of
        processes when constructing bootstrap samples. Default will use all the
        cores available.""")
    parser.add_argument(
        '--percentiles', '-p', metavar='percentile', type=float, nargs='+',
        help="""Percentiles to return in [0, 100]. By default all bootstrap
        values will be returned sorted.""")
    parser.add_argument(
        '--num-bootstraps', '-n', metavar='num-bootstraps', default=101,
        type=int, help="""The number of bootstrap samples to acquire. More
        samples takes longer, but in general the percentiles requested should
        be a multiple of this number minus 1, otherwise there will be some
        error due to linear interpolation between points.  (default:
        %(default)s)""")
    parser.add_argument(
        '--mean', '-m', action='store_true', help="""Also compute the mean
        statistic and return it as well. This will be in each dictionary with
        the key 'mean'.""")
    return parser


[docs]def main(args):
    game, serial = gameio.read_samplegame(json.load(args.input))
    profiles = np.concatenate([serial.from_prof_json(p)[None] for p
                               in scriptutils.load_profiles(args.profiles)])
    bootf, meanf = CHOICES[args.type]
    results = bootf(game, profiles, args.num_bootstraps, args.percentiles,
                    args.processes)
    if args.percentiles is None:
        args.percentiles = np.linspace(0, 100, args.num_bootstraps)
    percentile_strings = [str(p).rstrip('0').rstrip('.')
                          for p in args.percentiles]
    jresults = [{p: v.item() for p, v in zip(percentile_strings, boots)}
                for boots in results]
    if args.mean:
        for jres, mix in zip(jresults, profiles):
            jres['mean'] = meanf(game, mix)

    json.dump(jresults, args.output)
    args.output.write('\n')