How to use the toolz.partial function in toolz

def main2():
    """Mit modul application (aber ohne deap)."""

    mate = application.MateFactory.create(dict(mating='cxonepoint', mating_max_height=20), Individual)
    mutate = application.MutateFactory.create(dict(mutation='mutuniform', mutation_max_height=20), Individual)
    select = application.SelectFactory.create(dict(select='nsga2'))
    create = application.CreateFactory.create(dict(create_method='halfandhalf', create_min_height=1, create_max_height=4), Individual)
    algorithm_config = dict(algorithm='nsga2', crossover_prob=0.5,  mutation_prob=0.2, tournament_size=2)
    algorithm_factory = partial(application.AlgorithmFactory.create, algorithm_config, mate, mutate, select, create)
    runner = application.GPRunner(Individual, algorithm_factory, update_fitness)

    runner.init(pop_size=pop_size)
    for gen in range(10):
        runner.step()
        print(runner.logbook.stream)
    for individual in runner.pareto_front:
        print(individual)

"""Run image feature computation.

    Parameters
    ----------
    args : argparse.Namespace
        The arguments parsed by the argparse library.
    """
    if args.global_threshold:
        images = map(io.imread, args.images)
        thresholds = pre.global_threshold(images, args.random_seed)
    else:
        thresholds = None
    images = map(io.imread, args.images)
    screen_info = screens.d[args.screen]
    index_function, fmap = screen_info['index'], screen_info['fmap']
    fmap = tz.partial(fmap, threshold=thresholds,
                            sample_size=args.sample_size,
                            random_seed=args.random_seed)
    indices = list(map(index_function, args.images))
    f0, feature_names = fmap(next(images))
    feature_vectors = tz.cons(f0, (fmap(im)[0] for im in images))
    online_scaler = StandardScaler()
    online_pca = cluster.OnlineIncrementalPCA(n_components=args.n_components,
                                              batch_size=args.pca_batch_size)
    nimages, nfeatures = len(args.images), len(f0)
    emit = io.emitter_function(args.emitter)
    with temporary_hdf5_dataset((nimages, nfeatures), 'float') as dset:
        # First pass: compute the features, compute the mean and SD,
        # compute the PCA
        for i, (idx, v) in enumerate(zip(indices, feature_vectors)):
            emit({'_id': idx, 'feature_vector': list(v)})
            dset[i] = v

def main1():
    """Komplett ohne modul application."""
    import deap

    mate = deap.gp.cxOnePoint
    expr_mut = partial(deap.gp.genFull, min_=0, max_=2)
    mutate = partial(deap.gp.mutUniform, expr=expr_mut, pset=Individual.pset)
    algorithm = gp.NSGA2(mate, mutate)

    population = Individual.create_population(pop_size)
    update_fitness(population)
    for gen in range(10):
        population = algorithm.evolve(population)
        update_fitness(population)
        print('generation:', gen)
    print('Solutions:', population)

pset = gp.sympy_primitive_set(categories=['algebraic', 'trigonometric', 'exponential'],
                              arguments=['y0', 'y1'])
Individual = gp.Individual(pset=pset, name="Individual")


def phenotype(individual):
    """Produce phenotype from Individual."""
    return gp.sympy_phenotype(individual)

# Setup dynamic system.
x = np.linspace(0.0, 2.0 * np.pi, 2000, dtype=np.float64)
dynsys = partial(control_problem.anharmonic_oscillator, omega=1.0, c=3.0 / 8.0, k=0.0)
# Define target of control.
target = np.sin(x)
# Define measure.
trajectory = compose(partial(control_problem.integrate, yinit=[1.0, 0.0], x=x), dynsys, phenotype)
rmse = partial(utils.numeric.rmse, target)
dynsys_measure = assessment.measure(rmse, pre=compose(lambda arr: arr[0], trajectory))
complete_measure = assessment.measure(dynsys_measure, len, post=assessment.replace_nan)


def update_fitness(population):
    invalid = [p for p in population if not p.fitness.valid]
    fitnesses = map(complete_measure, invalid)
    for ind, fit in zip(invalid, fitnesses):
        ind.fitness.values = fit
    return len(invalid)


def main1():
    """Komplett ohne modul application."""
    import deap

log_level = utils.logging.log_level(args.verbosity)
    utils.logging.load_config(
        config_file=args.logging_config, level=log_level, placeholders=dict(workdir=workdir)
    )

    if args.resume_file is not None:
        logger.debug("Loading checkpoint {}".format(args.resume_file))
        app = Application.from_checkpoint(args.resume_file)
        return app, args
    else:
        mate = MateFactory.create(args, IndividualClass)
        mutate = MutateFactory.create(args, IndividualClass)
        select = SelectFactory.create(args)
        create_method = CreateFactory.create(args, IndividualClass)
        algorithm_factory = toolz.partial(AlgorithmFactory.create, args, mate, mutate, select, create_method)
        parallel_factory = toolz.partial(ParallelizationFactory.create, args)
        assessment_runner = AssessmentRunnerClass(parallel_factory)
        gp_runner = GPRunner(IndividualClass, algorithm_factory, assessment_runner)
        app = Application(args, gp_runner, args.checkpoint_file, callbacks=callbacks)
        return app, args

def _filename(self, id):
        return cs.chained_filename(self, id)


### ArtifactSet logic


def _set_op(operator, *sets, labels=None):
    new_ids = t.reduce(operator, t.map(lambda s: s.artifact_ids, sets))
    return ArtifactSet(new_ids, labels)


set_union = t.partial(_set_op, ops.or_)
set_difference = t.partial(_set_op, ops.sub)
set_intersection = t.partial(_set_op, ops.and_)

artifact_set_properties = ['id', 'artifact_ids', 'created_at', 'labels']


class ArtifactSet(namedtuple('ArtifactSet', artifact_set_properties)):

    def __new__(cls, artifact_ids, labels=None, created_at=None, id=None):
        artifact_ids = t.map(_artifact_id, artifact_ids)
        labels = _check_labels_name(labels)
        ids = frozenset(artifact_ids)
        if id:
            set_id = id
        else:
            set_id = hash(ids)
        created_at = created_at if created_at else datetime.utcnow()
        return super(ArtifactSet, cls).__new__(cls, set_id, ids, created_at, labels)

def push_XX(message, state, storage, size):
    raw_value = state.code.read_raw(size)
    padded_value = pad_right(raw_value, size, b'\x00')

    logger.info('PUSH%s: %s', size, padded_value)
    state.stack.push(padded_value)

    state.consume_gas(COST_VERYLOW)


push1 = partial(push_XX, size=1)
push2 = partial(push_XX, size=2)
push3 = partial(push_XX, size=3)
push4 = partial(push_XX, size=4)
push5 = partial(push_XX, size=5)
push6 = partial(push_XX, size=6)
push7 = partial(push_XX, size=7)
push8 = partial(push_XX, size=8)
push9 = partial(push_XX, size=9)
push10 = partial(push_XX, size=10)
push11 = partial(push_XX, size=11)
push12 = partial(push_XX, size=12)
push13 = partial(push_XX, size=13)
push14 = partial(push_XX, size=14)
push15 = partial(push_XX, size=15)
push16 = partial(push_XX, size=16)
push17 = partial(push_XX, size=17)
push18 = partial(push_XX, size=18)
push19 = partial(push_XX, size=19)
push20 = partial(push_XX, size=20)
push21 = partial(push_XX, size=21)

arguments=['y0', 'y1'])
Individual = gp.Individual(pset=pset, name="Individual")


def phenotype(individual):
    """Produce phenotype from Individual."""
    return gp.sympy_phenotype(individual)

# Setup dynamic system.
x = np.linspace(0.0, 2.0 * np.pi, 2000, dtype=np.float64)
dynsys = partial(control_problem.anharmonic_oscillator, omega=1.0, c=3.0 / 8.0, k=0.0)
# Define target of control.
target = np.sin(x)
# Define measure.
trajectory = compose(partial(control_problem.integrate, yinit=[1.0, 0.0], x=x), dynsys, phenotype)
rmse = partial(utils.numeric.rmse, target)
dynsys_measure = assessment.measure(rmse, pre=compose(lambda arr: arr[0], trajectory))
complete_measure = assessment.measure(dynsys_measure, len, post=assessment.replace_nan)


def update_fitness(population):
    invalid = [p for p in population if not p.fitness.valid]
    fitnesses = map(complete_measure, invalid)
    for ind, fit in zip(invalid, fitnesses):
        ind.fitness.values = fit
    return len(invalid)


def main1():
    """Komplett ohne modul application."""
    import deap

def cli_files(obj, name_spec):
    index = SearchIndex(obj['rc']['index_dir'])
    name = name_spec.partition('[')[0]
    recipe = index.get(name)
    if not recipe:
        _fail("Recipe '%s' not found" % name)

    datasets_dir = obj['rc']['datasets_dir']
    get_location = toolz.partial(os.path.join, datasets_dir, name)

    files = list(recipes.match_files(recipe, name_spec))
    if files:
        for spec in files:
            click.echo(get_location(spec['filename']))
    else:
        _fail("File '%s' not found" % name_spec)

excepts = toolz.curry(toolz.excepts)
filter = toolz.curry(toolz.filter)
get = toolz.curry(toolz.get)
get_in = toolz.curry(toolz.get_in)
groupby = toolz.curry(toolz.groupby)
interpose = toolz.curry(toolz.interpose)
itemfilter = toolz.curry(toolz.itemfilter)
itemmap = toolz.curry(toolz.itemmap)
iterate = toolz.curry(toolz.iterate)
join = toolz.curry(toolz.join)
keyfilter = toolz.curry(toolz.keyfilter)
keymap = toolz.curry(toolz.keymap)
map = toolz.curry(toolz.map)
mapcat = toolz.curry(toolz.mapcat)
nth = toolz.curry(toolz.nth)
partial = toolz.curry(toolz.partial)
partition = toolz.curry(toolz.partition)
partition_all = toolz.curry(toolz.partition_all)
partitionby = toolz.curry(toolz.partitionby)
peekn = toolz.curry(toolz.peekn)
pluck = toolz.curry(toolz.pluck)
random_sample = toolz.curry(toolz.random_sample)
reduce = toolz.curry(toolz.reduce)
reduceby = toolz.curry(toolz.reduceby)
remove = toolz.curry(toolz.remove)
sliding_window = toolz.curry(toolz.sliding_window)
sorted = toolz.curry(toolz.sorted)
tail = toolz.curry(toolz.tail)
take = toolz.curry(toolz.take)
take_nth = toolz.curry(toolz.take_nth)
topk = toolz.curry(toolz.topk)
unique = toolz.curry(toolz.unique)