def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
global resource_holders
global entrepreneurs
pa = init_props(MODEL_NAME, props, model_dir="capital")
entrepreneurs = Composite("Entrepreneurs", {"color": BLUE},
member_creator=create_entr,
props=pa,
num_members=pa.get('num_entr', DEF_NUM_ENTR))
resource_holders = Composite("Resource_holders", {"color": RED},
member_creator=create_rholder,
props=pa,
num_members=pa.get('num_rholder',
DEF_NUM_RHOLDER))
Env("neighborhood",
height=get_prop('grid_height', DEF_HEIGHT),
width=get_prop('grid_width', DEF_WIDTH),
members=[resource_holders, entrepreneurs])
return resource_holders, entrepreneurs
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
init_props(MODEL_NAME, props)
groups = []
groups.append(
Composite("value_investors", {"color": BLUE},
member_creator=create_value_investor,
num_members=get_prop("value_investors",
DEF_NUM_VALUE_INVESTOR)))
groups.append(
Composite("trend_followers", {"color": RED},
member_creator=create_trend_follower,
num_members=get_prop("trend_followers",
DEF_NUM_TREND_FOLLOWER)))
groups.append(create_market_maker("market_maker"))
Env("fmarket",
members=groups,
width=UNLIMITED,
height=UNLIMITED,
census=market_report,
line_data_func=plot_asset_price)
get_env().exclude_menu_item("scatter_plot")
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
global population
global optimal_occupancy
global agents_decided
init_props(MODEL_NAME, props)
agents_decided = 0
drinkers = Composite(DRINKERS, {"color": RED},
member_creator=create_drinker,
num_members=get_prop('population',
DEF_POPULATION) // 2)
non_drinkers = Composite(NON_DRINKERS, {"color": BLUE},
member_creator=create_non_drinker,
num_members=get_prop('population',
DEF_POPULATION) // 2)
population = len(drinkers) + len(non_drinkers)
optimal_occupancy = int(population * 0.6)
Env("bar",
height=get_prop('grid_height', DEF_HEIGHT),
width=get_prop('grid_width', DEF_WIDTH),
members=[drinkers, non_drinkers])
def create_rholder(name, i, props=None):
"""
Create an agent.
"""
k_price = DEF_K_PRICE
resources = copy.deepcopy(DEF_CAP_WANTED)
num_resources = len(resources)
price_list = copy.deepcopy(DEF_EACH_CAP_PRICE)
if props is not None:
k_price = props.get('cap_price', DEF_K_PRICE)
for k in price_list.keys():
price_list[k] = float("{0:.2f}".format(
float(k_price * random.uniform(0.5, 1.5))))
starting_cash = DEF_RHOLDER_CASH
if props is not None:
starting_cash = get_prop('rholder_starting_cash', DEF_RHOLDER_CASH)
if props is not None:
total_resources = get_prop('rholder_starting_resource_total',
DEF_TOTAL_RESOURCES_RHOLDER_HAVE)
for k in resources.keys():
resources[k] = int(
(total_resources * 2) * (random.random() / num_resources))
return Agent(name + str(i),
action=rholder_action,
attrs={
"cash": starting_cash,
"resources": resources,
"price": price_list
})
def create_central_bank(name, i):
"""
Create the central bank to distribute the coupons
"""
central_bank = Agent(name, action=central_bank_action)
central_bank["percent_change"] = get_prop("percent_change", DEF_PERCENT)
central_bank["extra_coupons"] = get_prop("extra_coupons", DEF_COUPON)
central_bank["extra_dev"] = get_prop("extra_deviation", DEF_SIGMA)
return central_bank
def create_babysitter(name, i):
"""
Create a babysitter.
"""
babysitter = Agent(name + str(i), action=babysitter_action)
mean_coupons = get_prop("average_coupons", DEF_COUPON)
dev = get_prop("deviation", DEF_SIGMA)
babysitter["goal"] = None
babysitter['coupons'] = int(gaussian(mean_coupons, dev))
babysitter['desired_cash'] = get_prop("desired_cash", DEF_DESIRED_CASH_BAL)
return babysitter
def create_trend_follower(name, i):
"""
Create a trend follower.
"""
average_period = get_prop("average_period", DEF_PERIODS)
dev = get_prop("deviation_follower", DEF_SIGMA)
trend_follower = Agent(name + str(i), action=trend_follower_action)
trend_follower["change_period"] = gaussian(average_period, dev)
trend_follower["capital"] = DEF_CAPITAL
trend_follower["num_stock"] = 0
return trend_follower
def create_value_investor(name, i):
"""
Create a value investor.
"""
value_investor = Agent(name + str(i), action=value_investor_action)
mean_price = get_prop("discount", DEF_DISCOUNT)
dev = get_prop("deviation_investor", DEF_SIGMA)
low_val_percentage = gaussian(mean_price, dev)
high_val_percentage = gaussian(mean_price, dev)
value_investor["low_price"] = DEF_REAL_VALUE * (1 - low_val_percentage)
value_investor["high_price"] = DEF_REAL_VALUE * (1 + high_val_percentage)
value_investor["capital"] = DEF_CAPITAL
value_investor["num_stock"] = 0
return value_investor
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
init_props(MODEL_NAME, props)
blue_group = Composite("Blues", {"color": BLUE},
member_creator=create_agent,
num_members=get_prop('num_blue', DEF_NUM_BLUE))
red_group = Composite("Reds", {"color": RED},
member_creator=create_agent,
num_members=get_prop('num_red', DEF_NUM_RED))
Env("env",
height=get_prop('grid_height', DEF_HEIGHT),
width=get_prop('grid_width', DEF_WIDTH),
members=[blue_group, red_group])
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
init_props(MODEL_NAME, props)
num_members = get_prop('num_babysitter', DEF_BABYSITTER)
co_op_members = Composite(CO_OP_MEMBERS,
num_members=num_members,
member_creator=create_babysitter)
central_bank = Composite("central_bank",
num_members=1,
member_creator=create_central_bank)
Env('coop_env',
members=[co_op_members, central_bank],
action=coop_action,
width=UNLIMITED,
height=UNLIMITED,
census=coop_report,
pop_hist_setup=initial_exchanges,
pop_hist_func=record_exchanges,
attrs={
"show_special_points": CB_intervention_points,
"special_points_name": "CB intervention points"
})
def create_toxin(name, i):
"""
Create a toxin.
"""
toxin = Agent(name + str(i), action=toxin_action)
toxin["max_move"] = get_prop("toxin_move", DEF_TOXIN_MOVE)
return toxin
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
# global max_util -> not in use now
init_props(MODEL_NAME, props, model_dir="capital")
traders = Composite("Traders",
member_creator=create_trader,
num_members=get_prop('num_traders', DEF_NUM_TRADERS))
nature_to_traders(traders, natures_goods)
Env("MengerMoney",
height=get_prop('grid_height', DEF_HEIGHT),
width=get_prop('grid_width', DEF_WIDTH),
members=[traders],
attrs={"goods": natures_goods})
def create_nutrient(name, i):
"""
Create a nutrient.
"""
nutrient = Agent(name + str(i), action=nutrient_action)
nutrient["max_move"] = get_prop("nutrient_move",
DEF_NUTRIENT_MOVE)
return nutrient
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
init_props(MODEL_NAME, props)
blue_agents = Composite(group_names[BLUE_TEAM],
{"color": BLUE},
member_creator=create_resident,
num_members=get_prop('num_blue',
NUM_BLUE))
red_agents = Composite(group_names[RED_TEAM],
{"color": RED},
member_creator=create_resident,
num_members=get_prop('num_red', NUM_RED))
city = Env("A city", members=[blue_agents, red_agents],
height=get_prop('grid_height', DEF_CITY_DIM),
width=get_prop('grid_width', DEF_CITY_DIM))
city.exclude_menu_item("line_graph")
def set_up(num_dealers, props=None): # testcase???
"""
A func to set up run that can also be used by test code.
"""
init_props(MODEL_NAME, props)
group = []
group.append(
Composite(DEALER_GRP, {"color": BLUE},
member_creator=create_dealer,
num_members=num_dealers))
group.append(
Composite(BUYER_GRP, {"color": RED},
member_creator=create_buyer,
num_members=get_prop('num_buyers', DEF_NUM_RED)))
Env("Car market",
height=get_prop('grid_height', DEF_HEIGHT),
width=get_prop('grid_width', DEF_WIDTH),
members=group)
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
global max_utility
pa = init_props(MODEL_NAME, props, model_dir="capital")
trader_group = Composite("trader", {"color": BLUE},
member_creator=create_trader,
props=pa,
num_members=get_prop('num_traders',
DEF_NUM_TRADER))
Env("env",
height=get_prop('grid_height', DEF_HEIGHT),
width=get_prop('grid_width', DEF_WIDTH),
members=[trader_group])
for trader in trader_group:
allocate_resources(trader_group[trader], GOODS)
get_env().user.tell(trader_group[trader]["goods"])
return (trader_group, max_utility)
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
init_props(MODEL_NAME, props)
members = []
members.append(Composite(WOLF_GROUP,
attrs={"color": TAN},
member_creator=create_wolf,
num_members=get_prop('num_wolves', NUM_WOLVES)))
members.append(Composite(SHEEP_GROUP,
attrs={"color": GRAY},
member_creator=create_sheep,
num_members=get_prop('num_sheep', NUM_SHEEP)))
Env("meadow", members=members,
height=get_prop('meadow_height', MEADOW_HEIGHT),
width=get_prop('meadow_width', MEADOW_WIDTH))
def create_bacterium(name, i):
"""
Create a baterium.
"""
bacterium = Agent(name + str(i), action=bacterium_action)
bacterium["prev_toxicity"] = None
bacterium["prev_nutricity"] = None
bacterium["angle"] = None
bacterium["max_move"] = get_prop("bacterium_move",
DEF_BACTERIUM_MOVE)
return bacterium
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
global max_util
pa = init_props(MODEL_NAME, props, model_dir="capital")
cheese_group = Composite("Cheese holders", {"color": BLUE},
member_creator=create_cagent,
props=pa,
num_members=get_prop('num_cagents',
DEF_NUM_CAGENTS))
wine_group = Composite("Wine holders", {"color": RED},
member_creator=create_wagent,
props=pa,
num_members=get_prop('num_wagents',
DEF_NUM_WAGENTS))
Env("EdgeworthBox",
height=get_prop('grid_height', DEF_HEIGHT),
width=get_prop('grid_width', DEF_WIDTH),
members=[cheese_group, wine_group])
start_cheese = 0
start_wine = 0
if pa is not None:
start_cheese = get_prop('start_cheese', DEF_NUM_CHEESE)
start_wine = get_prop('start_wine', DEF_NUM_WINE)
max_util = max(start_cheese, start_wine)
else:
props_max_util = max(start_cheese, start_wine)
max_util = max(props_max_util, DEF_MAX_UTIL)
return (cheese_group, wine_group, max_util)
def create_resident(name, i):
"""
Creates agent of specified color type
"""
if "Blue" in name:
color = 0
mean_tol = get_prop('mean_tol', DEF_TOLERANCE)
else:
color = 1
mean_tol = -get_prop('mean_tol', DEF_TOLERANCE)
dev = get_prop('deviation', DEF_SIGMA)
this_tolerance = get_tolerance(mean_tol,
dev)
return Agent(name + str(i),
action=seg_agent_action,
attrs={TOLERANCE: this_tolerance,
COLOR: color, "hood_changed": True,
"just_moved": False,
"hood_size": get_prop('hood_size',
DEF_HOOD_SIZE)
}, )
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
init_props(MODEL_NAME, props)
toxins = Composite(TOXINS, {"color": RED},
member_creator=create_toxin,
num_members=get_prop('num_toxins', NUM_TOXINS))
nutrients = Composite(NUTRIENTS, {"color": GREEN},
member_creator=create_nutrient,
num_members=get_prop('num_nutrients', NUM_TOXINS))
bacteria = Composite("Bacteria", {"color": BLUE},
member_creator=create_bacterium,
num_members=get_prop('num_toxins',
DEF_NUM_BACT))
Env("Petrie dish",
height=get_prop('grid_height', DEF_HEIGHT),
width=get_prop('grid_width', DEF_WIDTH),
members=[toxins, nutrients, bacteria])
def set_up(props=None):
"""
A func to set up run that can also be used by test code.
"""
init_props(MODEL_NAME, props)
forest_height = get_prop('grid_height', DEF_DIM)
forest_width = get_prop('grid_width', DEF_DIM)
forest_density = get_prop('density', DEF_DENSITY)
tree_cnt = int(forest_height * forest_width * forest_density)
groups = []
groups.append(
Composite(HEALTHY, {
"color": GREEN,
"marker": TREE
},
member_creator=plant_tree,
num_members=tree_cnt))
groups.append(Composite(NEW_FIRE, {"color": TOMATO, "marker": TREE}))
groups.append(Composite(ON_FIRE, {"color": RED, "marker": TREE}))
groups.append(Composite(BURNED_OUT, {"color": BLACK, "marker": TREE}))
groups.append(Composite(NEW_GROWTH, {
"color": SPRINGGREEN,
"marker": TREE
}))
Env("Forest", height=forest_height, width=forest_width, members=groups)
global group_map
group_map = {
HE: groups[HE],
NF: groups[NF],
OF: groups[OF],
BO: groups[BO],
NG: groups[NG]
}
def create_entr(name, i, props=None):
"""
Create an agent.
"""
starting_cash = DEF_ENTR_CASH
if props is not None:
starting_cash = get_prop('entr_starting_cash', DEF_ENTR_CASH)
resources = copy.deepcopy(DEF_CAP_WANTED)
if props is not None:
total_resources = get_prop('entr_want_resource_total',
DEF_TOTAL_RESOURCES_ENTR_WANT)
num_resources = len(resources)
for k in resources.keys():
resources[k] = int(
(total_resources * 2) * (random.random() / num_resources))
return Agent(name + str(i),
action=entr_action,
attrs={
"cash": starting_cash,
"wants": resources,
"have": {}
})
def set_menu_excludes(self):
if not get_prop('use_line', True):
self.exclude_menu_item("line_graph")
if not get_prop('use_scatter', True):
self.exclude_menu_item("scatter_plot")
def test_get_prop_no_pa(self):
"""
No prop args set up... can we still get prop ok?
"""
prop_val = get_prop("key", "default")
self.assertEqual(prop_val, "default")
