def create_distributors_with_sims(self):
"""
Distributors are similar to dealers, just with much more sims, and the
stories to buy SIM from them is "by bulks" (though the story is not
created here)
"""
logging.info("Creating distributors and their SIM stock ")
distributors = self.create_population(name="distros",
size=params["n_distributors"],
ids_gen=SequencialGenerator(
prefix="DISTRIBUTOR_",
max_length=1))
sims = distributors.create_relationship(name="SIM")
sim_generator = SequencialGenerator(prefix="SIM_", max_length=30)
sim_ids = sim_generator.generate(params["n_init_sims_distributor"])
sims_dist = make_random_assign(set1=sim_ids,
set2=distributors.ids,
seed=next(self.seeder))
sims.add_relations(from_ids=sims_dist["chosen_from_set2"],
to_ids=sims_dist["set1"])
# this tells to the "restock" story of the distributor how many
# sim should be re-generated to replenish the stocks
distributors.create_attribute("SIMS_TO_RESTOCK", init_values=0)
return distributors, sim_generator
def create_dealers_and_sims_stock(self):
"""
Create the DEALER population together with their init SIM stock
"""
logging.info("Creating dealer and their SIM stock ")
dealers = self.create_population(name="dealers",
size=params["n_dealers"],
ids_gen=SequencialGenerator(
prefix="DEALER_", max_length=3))
# SIM relationship to maintain some stock
sims = dealers.create_relationship(name="SIM")
sim_ids = build_ids(size=params["n_init_sims_dealer"], prefix="SIM_")
sims_dealer = make_random_assign(set1=sim_ids,
set2=dealers.ids,
seed=next(self.seeder))
sims.add_relations(from_ids=sims_dealer["chosen_from_set2"],
to_ids=sims_dealer["set1"])
# one more dealer with just 3 sims in stock => this one will trigger
# lot's of failed sales
broken_dealer = pd.DataFrame({
"DEALER":
"broke_dealer",
"SIM": ["SIM_OF_BROKE_DEALER_%d" % s for s in range(3)]
})
sims.add_relations(from_ids=broken_dealer["DEALER"],
to_ids=broken_dealer["SIM"])
return dealers
def test_make_random_assign_shoud_assign_each_element_only_once():
dealers = build_ids(size=10, prefix="DEALER_", max_length=2)
sims = build_ids(size=1000, prefix="SIM_", max_length=4)
assignment = make_random_assign(set1=sims, set2=dealers, seed=10)
# all sims should have been assigned
assert assignment.shape == (1000, 2)
# all SIM should have been given
assert set(assignment["set1"].unique().tolist()) == set(sims)
# all owners should be part of the dealers
assert set(
assignment["chosen_from_set2"].unique().tolist()) <= set(dealers)
def build_uganda_populations(circus):
seeder = seed_provider(12345)
cells = circus.create_population(name="cells",
ids_gen=SequencialGenerator(prefix="CELL_"),
size=200)
latitude_generator = FakerGenerator(method="latitude",
seed=next(seeder))
cells.create_attribute("latitude", init_gen=latitude_generator)
longitude_generator = FakerGenerator(method="longitude",
seed=next(seeder))
cells.create_attribute("longitude", init_gen=longitude_generator)
# the cell "health" is its probability of accepting a call. By default
# let's says it's one expected failure every 1000 calls
healthy_level_gen = build_healthy_level_gen(next(seeder))
cells.create_attribute(name="HEALTH", init_gen=healthy_level_gen)
city_gen = FakerGenerator(method="city", seed=next(seeder))
cities = circus.create_population(name="cities", size=200, ids_gen=city_gen)
cell_city_rel = cities.create_relationship("CELLS")
cell_city_df = make_random_assign(cells.ids, cities.ids, next(seeder))
cell_city_rel.add_relations(
from_ids=cell_city_df["chosen_from_set2"],
to_ids=cell_city_df["set1"])
pop_gen = ParetoGenerator(xmin=10000, a=1.4, seed=next(seeder))
cities.create_attribute("population", init_gen=pop_gen)
timer_config = CyclicTimerProfile(
profile=[1, .5, .2, .15, .2, .4, 3.8,
7.2, 8.4, 9.1, 9.0, 8.3, 8.1,
7.7, 7.4, 7.8, 8.0, 7.9, 9.7,
10.4, 10.5, 8.8, 5.7, 2.8],
profile_time_steps="1h",
start_date=pd.Timestamp("6 June 2016 00:00:00"))
return cells, cities, timer_config
def create_stock_relationship(self, name, item_id_gen, n_items_per_member):
"""
Creates a relationship aimed at maintaining a stock, from a generator
that create stock item ids.
The relationship does not point to another population, but to items
whose id is generated with the provided generator.
"""
logging.info("generating initial {} stock".format(name))
rel_to_items = self.create_relationship(name=name)
assigned_items = make_random_assign(
set1=item_id_gen.generate(size=n_items_per_member * self.size),
set2=self.ids,
seed=next(self.circus.seeder))
rel_to_items.add_relations(from_ids=assigned_items["chosen_from_set2"],
to_ids=assigned_items["set1"])