def pick(subset, weighted=False):
    if weighted:
        d = {(name, weight): weight for name, weight in subset}
        picked = weighted_lottery(d)
    else:
        picked = random.choice(subset)
    return picked

def lottery_promoted_links(srids, n=10):
    """Run weighted_lottery to order and choose a subset of promoted links."""
    promo_tuples = get_promotion_list(srids)
    weights = {p: p.weight for p in promo_tuples if p.weight}
    selected = []
    while weights and len(selected) < n:
        s = weighted_lottery(weights)
        del weights[s]
        selected.append(s)
    return selected

def choose_random_item(keep_fn=None):
    item_class = weighted_lottery(g.live_config["f2p_rarity_weights"])
    items_in_class = [i["kind"] for i in g.f2pitems.itervalues() if i.get("rarity", "common") == item_class]

    if keep_fn:
        available_items = [i for i in items_in_class if keep_fn(i)]
    else:
        available_items = items_in_class

    return random.choice(available_items)

def lottery_promoted_links(sr_names, n=10):
    """Run weighted_lottery to order and choose a subset of promoted links."""
    promo_tuples = get_live_promotions(sr_names)

    # house priority campaigns have weight of 0, use some small value
    # so they'll show if there are no other campaigns
    weights = {p: p.weight or 0.001 for p in promo_tuples}
    selected = []
    while weights and len(selected) < n:
        s = weighted_lottery(weights)
        del weights[s]
        selected.append(s)
    return selected

    def generate(self):
        """Generate a string similar to samples previously fed in."""

        start = weighted_lottery(self.starts)
        desired_length = weighted_lottery(self.start_lengths[start])
        desired_length = max(desired_length, self.order)

        generated = []
        generated.extend(start)
        while len(generated) < desired_length:
            # try each model, from highest order down, til we find
            # something
            for order, model in reversed(list(enumerate(self.models, 1))):
                current_prefix = "".join(generated[-order:])
                frequencies = model[current_prefix]
                if frequencies:
                    generated.append(weighted_lottery(frequencies))
                    break
            else:
                generated.append(random.choice(string.lowercase))

        return "".join(generated)

def select_subset(n, weighted=False):
    promos = copy(PROMOS)
    selected = []

    if weighted:
        d = {(name, weight): weight for name, weight in promos}
        while len(selected) < n and d:
            i = weighted_lottery(d)
            del d[i]
            selected.append(i)
    else:
        # Sample without replacement
        if n > len(promos):
            return promos
        else:
            return random.sample(promos, n)
    return selected

 def expect(result, random_value):
     scaled_r = float(random_value) / sum(weights.itervalues())
     self.assertEquals(
         result,
         utils.weighted_lottery(weights, _random=lambda: scaled_r))