def bank__set_parameters(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.set_parameters \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info('START logging for test bank__set_parameters in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
text = "Original parameters:"
print(text)
print(bank.get_parameters())
text = "New parameters:"
print(text)
bank.set_parameters({'rd': 0.44, 'rl': 0.55, 'active': 1})
print(bank.get_parameters())
def market__tatonnement(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
text = "This test checks market.tatonnement \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info('START logging for test market__tatonnement in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
sellers = []
for agent in environment.households:
sellers.append([agent, agent.supply_of_labour])
buyers = []
for agent in environment.firms:
buyers.append([agent, agent.demand_for_labour])
starting_price = 0.0
price = 0.0
market = Market("market")
price = market.tatonnement(sellers, buyers, starting_price, 0.00000001,
0.01, 1.1)
print("Price found through tatonnement:")
print(price)
def central_bank__getattr(self, args):
import os
from src.bank import Bank
from src.central_bank import CentralBank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks central_bank.getattr \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test central_bank__getattr in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a central bank
cb = CentralBank()
cb.identifier = "test_central_bank"
environment.central_bank.append(cb)
#
# TESTING
#
print('Accessing rates through bank.parameters["interest_rate_cb_loans"] :')
print(cb.parameters["interest_rate_cb_loans"])
print("Accessing rates through bank.interest_rate_cb_loans:")
print(cb.interest_rate_cb_loans)
def measurement__set_csv_writer(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
from src.runner import Runner
from src.measurement import Measurement
text = "This test checks measurement.set_csv_writer \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test measurement__set_csv_writer in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# Construct a runner
runner = Runner(environment)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
import csv
file_new = open("__init__.py", "r")
csv_writer = csv.writer(file_new, lineterminator='\n')
measurement = Measurement(environment, runner)
print("Measurement's csv_writer:")
print(measurement.get_csv_writer())
measurement.set_csv_writer(csv_writer)
print("Measurement's csv_writer:")
print(measurement.get_csv_writer())
def central_bank__str(self, args):
import os
from src.bank import Bank
from src.central_bank import CentralBank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks central_bank.str \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info('START logging for test central_bank__str in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a central bank
cb = CentralBank()
cb.identifier = "test_central_bank"
environment.central_bank.append(cb)
#
# TESTING
#
print(cb.__str__())
def bank__get_transactions_from_file(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.get_transactions_from_file \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test bank__get_transactions_from_file in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
#
# TESTING
#
environment.banks[0].clear_accounts()
print("Printing bank: \n")
print(environment.banks[0])
print("Reading transactions from the config file.\n")
print("Printing bank: \n")
bank.get_transactions_from_file(bank_directory + listing[0],
environment)
print(environment.banks[0])
def bank__set_state_variables(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.set_state_variables \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__set_state_variables in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
text = "Original state variables:"
print(text)
print(bank.get_state_variables())
text = "New state variables:"
print(text)
bank.set_state_variables({'test': 0.66})
print(bank.get_state_variables())
def household__set_identifier(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks household.set_identifier \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test household__set_identifier in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# get the firm_directory from the environment
household_directory = environment.household_directory
# and loop over all firms in the directory
listing = os.listdir(household_directory)
householdFilename = household_directory + listing[0]
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
environment.households.append(household)
helper = Helper()
helper.initialize_standard_household(household, environment)
#
# TESTING
#
text = "Original identifier: "
text = text + household.get_identifier()
print(text)
household.set_identifier("new_ident")
text = "New identifier: "
text = text + household.get_identifier()
print(text)
def market__tatonnement(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
text = "This test checks market.tatonnement \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test market__tatonnement in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
sellers = []
for agent in environment.households:
sellers.append([agent, agent.supply_of_labour])
buyers = []
for agent in environment.firms:
buyers.append([agent, agent.demand_for_labour])
starting_price = 0.0
price = 0.0
market = Market("market")
price = market.tatonnement(sellers, buyers, starting_price, 0.00000001, 0.01, 1.1)
print("Price found through tatonnement:")
print(price)
def updater__set_model_parameters(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
from src.updater import Updater
text = "This test checks updater.set_model_parameters \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test updater__set_model_parameters in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
model = Updater(environment)
model.model_parameters = {"test": "model parameters"}
print("Model's parameters:")
print(model.get_model_parameters())
print("Changing model's parameters:...")
model.model_parameters = {"new": "model parameters"}
print("Model's parameters:")
print(model.get_model_parameters())
def transaction__add_transaction(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
text = "This test checks transaction.add_transaction \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test transaction__add_transaction in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
print("Creating a transaction")
transaction = Transaction()
print("Assigning values")
transaction.this_transaction("type", "asset", "test_household", "test_firm", 1, 2, 3, 4)
print("Adding the transaction to the books")
transaction.add_transaction(environment)
print("The transaction:")
print(transaction)
print("The firm:")
print(environment.get_agent_by_id("test_firm"))
print("The household:")
print(environment.get_agent_by_id("test_household"))
def bank__get_transactions_from_file(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.get_transactions_from_file \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__get_transactions_from_file in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
#
# TESTING
#
environment.banks[0].clear_accounts()
print("Printing bank: \n")
print(environment.banks[0])
print("Reading transactions from the config file.\n")
print("Printing bank: \n")
bank.get_transactions_from_file(bank_directory + listing[0], environment)
print(environment.banks[0])
def updater__accrue_interests(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
from src.updater import Updater
text = "This test checks updater.accrue_interests \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test updater__accrue_interests in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
bank.interest_rate_deposits = 0.05
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
model = Updater(environment)
model.__init__(environment)
environment.new_transaction("deposits", "", environment.get_agent_by_id("test_household").identifier, environment.get_agent_by_id("test_bank"),
10.0, environment.get_agent_by_id("test_bank").interest_rate_deposits, 0, -1)
print(environment.get_agent_by_id("test_household"))
print("Accruing interests\n")
model.accrue_interests(environment, 0)
print(environment.get_agent_by_id("test_household"))
def market__set_amplification(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
text = "This test checks market.set_amplification \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test market__set_amplification in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
market = Market("market_id")
print("Market's amplification:")
print(market.get_amplification())
print("Changing amplification")
market.set_amplification(0.55)
print("Market's amplification:")
print(market.get_amplification())
def market__rationing_proportional(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
text = "This test checks market.rationing_proportional \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test market__rationing_proportional in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
market = Market("market")
rationed = market.rationing_proportional([["agent1", 5], ["agent2", 7],
["agent3", -3],
["agent4", -4]])
print("Pairs found through proportional rationing:")
print(rationed)
def updater__set_model_parameters(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
from src.updater import Updater
text = "This test checks updater.set_model_parameters \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test updater__set_model_parameters in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
model = Updater(environment)
model.model_parameters = {"test": "model parameters"}
print("Model's parameters:")
print(model.get_model_parameters())
print("Changing model's parameters:...")
model.model_parameters = {"new": "model parameters"}
print("Model's parameters:")
print(model.get_model_parameters())
def helper__initialize_standard_bank(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.helper import Helper
text = "This test checks helper.initialize_standard_bank \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test helper__initialize_standard_bank in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
# bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
helper = Helper()
helper.initialize_standard_bank(bank, environment)
print("Initialized standard bank")
print(bank)
def market__set_amplification(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
text = "This test checks market.set_amplification \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test market__set_amplification in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
market = Market("market_id")
print("Market's amplification:")
print(market.get_amplification())
print("Changing amplification")
market.set_amplification(0.55)
print("Market's amplification:")
print(market.get_amplification())
def helper__initialize_standard_bank(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.helper import Helper
text = "This test checks helper.initialize_standard_bank \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test helper__initialize_standard_bank in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
# bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
helper = Helper()
helper.initialize_standard_bank(bank, environment)
print("Initialized standard bank")
print(bank)
def market__rationing_proportional(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
text = "This test checks market.rationing_proportional \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test market__rationing_proportional in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
market = Market("market")
rationed = market.rationing_proportional([["agent1", 5], ["agent2", 7], ["agent3", -3], ["agent4", -4]])
print("Pairs found through proportional rationing:")
print(rationed)
def bank__get_account_num_transactions(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.get_account_num_transactions \n"
text = text + " The purpose of this method is to count the numbers of transaction for \n"
text = text + " accounts banks hold. Our standard bank has 3 transactions by default. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__get_account_num_transactions in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
num_transactions = 0.0 # counting all types in account together
print(bank)
# and checking if the number of transaction
# is increasing by one
for type in ["deposits", "cash", "loans"]:
if type == "deposits":
num_transactions = num_transactions + bank.get_account_num_transactions(type)
print("D = " + str(num_transactions))
if type == "cash":
num_transactions = num_transactions + bank.get_account_num_transactions(type)
print("D+M = " + str(num_transactions))
if type == "loans":
num_transactions = num_transactions + bank.get_account_num_transactions(type)
print("D+M+L = " + str(num_transactions))
def bank__clear_accounts(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.clear_accounts \n"
text = text + " Checking if after the clear_accounts the total amount \n"
text = text + " of transactions in zero. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__clear_accounts in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
bank.add_transaction("deposits", "", "test_household",
bank.identifier, 0.0, 0.09, 0, -1, environment)
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
for bank in environment.banks:
print(bank)
for firm in environment.firms:
print(firm)
for household in environment.households:
print(household)
bank.clear_accounts(environment)
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
def bank__purge_accounts(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.purge_accounts \n"
text = text + " Checking if after the purge_accounts the total amount \n"
text = text + " of transactions in the bank stays the same. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__purge_accounts in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
bank.add_transaction("deposits", "", "test_household",
bank.identifier, 0.0, 0.09, 0, -1, environment)
# environment.households[0:1][0] is only for testing purposes DO NOT USE IN PRODUCTION
# what it does is is takes the first household in environment, but if there are no
# households (which happens in testing) it doesn't break down
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
bank.accounts[0].purge_accounts(environment)
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
def bank__check_consistency(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.check_consitency \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__check_consistency in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
print("Checking consistency of the standard bank: ")
print(bank.check_consistency())
print("Adding additional deposits without adding appropriate cash/loans.")
bank.add_transaction("deposits", "", environment.get_agent_by_id("test_household"),
bank, 150, bank.interest_rate_deposits, 0, -1, environment)
# environment.households[0:1][0] is only for testing purposes DO NOT USE IN PRODUCTION
# what it does is is takes the first household in environment, but if there are no
# households (which happens in testing) it doesn't break down
print("Checking consistency of the standard bank: ")
print(bank.check_consistency())
def central_bank__get_account(self, args):
import os
from src.bank import Bank
from src.central_bank import CentralBank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks central_bank.get_account \n"
text = text + " The method simply adds all kinds of assets and stores \n"
text = text + " them in one volume. The central banks holds 600 in assets. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test central_bank__get_account in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a central bank
cb = CentralBank()
cb.identifier = "test_central_bank"
environment.central_bank.append(cb)
#
# TESTING
#
environment.new_transaction("deposits", "", cb.identifier, "test_firm",
100, 0.0, 0, -1)
environment.new_transaction("cash", "", cb.identifier, "test_firm",
200, 0.0, 0, -1)
environment.new_transaction("loans", "", cb.identifier, "test_firm",
300, 0.0, 0, -1)
account = 0.0 # counting all types in account together
print(cb) # and checking how much is the total
# volume of the account
for type in ["deposits", "cash", "loans"]:
if type == "deposits":
account = account + cb.get_account(type)
print("D = " + str(account))
if type == "cash":
account = account + cb.get_account(type)
print("D+M = " + str(account))
if type == "loans":
account = account + cb.get_account(type)
print("D+M+L = " + str(account))
def runner__init__(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the Directory
from src.runner import Runner
text = "This test checks runner.__init__ \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(
format="%(asctime)s %(message)s",
datefmt="%m/%d/%Y %H:%M:%S",
filename=log_directory + identifier + ".log",
level=logging.INFO,
)
logging.info("START logging for test runner__init__ in run: %s", environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory for testing purpose (just one bank)
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
# making an instance of the Runner class
runner = Runner(environment)
#
# TESTING
#
text = "Identifier: "
text = text + runner.get_identifier()
print(text)
text = "Number of sweeps:"
text = text + str(runner.num_sweeps)
print(text)
text = "Updater"
text = text + str(runner.updater)
print(text)
def household__get_parameters_from_file(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks household.get_parameters_from_file \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test household__get_parameters_from_file in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# get the household_directory from the environment
household_directory = environment.household_directory
# and loop over all firms in the directory
listing = os.listdir(household_directory)
householdFilename = household_directory + listing[0]
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
environment.households.append(household)
household.get_parameters_from_file(householdFilename, environment)
#
# TESTING
#
# test whether the parameters are read properly
text = "Identifier has been read as follows: \n"
text = text + "Identifier: "
text = text + household.identifier
text = text + "\n"
text = text + "Amount of labour: "
text = text + str(household.parameters["labour"])
text = text + "\n"
text = text + "Propensity to save: "
text = text + str(household.parameters["propensity_to_save"])
self.print_info(text)
def central_bank__get_account(self, args):
import os
from src.bank import Bank
from src.central_bank import CentralBank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks central_bank.get_account \n"
text = text + " The method simply adds all kinds of assets and stores \n"
text = text + " them in one volume. The central banks holds 600 in assets. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test central_bank__get_account in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a central bank
cb = CentralBank()
cb.identifier = "test_central_bank"
environment.central_bank.append(cb)
#
# TESTING
#
environment.new_transaction("deposits", "", cb.identifier, "test_firm",
100, 0.0, 0, -1)
environment.new_transaction("cash", "", cb.identifier, "test_firm",
200, 0.0, 0, -1)
environment.new_transaction("loans", "", cb.identifier, "test_firm",
300, 0.0, 0, -1)
account = 0.0 # counting all types in account together
print(cb) # and checking how much is the total
# volume of the account
for type in ["deposits", "cash", "loans"]:
if type == "deposits":
account = account + cb.get_account(type)
print("D = " + str(account))
if type == "cash":
account = account + cb.get_account(type)
print("D+M = " + str(account))
if type == "loans":
account = account + cb.get_account(type)
print("D+M+L = " + str(account))
def bank__check_consistency(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.check_consitency \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__check_consistency in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
print("Checking consistency of the standard bank: ")
print(bank.check_consistency())
print("Adding additional deposits without adding appropriate cash/loans.")
bank.add_transaction("deposits", "", environment.get_agent_by_id("test_household"),
bank, 150, bank.interest_rate_deposits, 0, -1, environment)
# environment.households[0:1][0] is only for testing purposes DO NOT USE IN PRODUCTION
# what it does is is takes the first household in environment, but if there are no
# households (which happens in testing) it doesn't break down
print("Checking consistency of the standard bank: ")
print(bank.check_consistency())
def central_bank__clear_accounts(self, args):
import os
from src.bank import Bank
from src.central_bank import CentralBank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks central_bank.clear_accounts \n"
text = text + " Checking if after the clear_accounts the total amount \n"
text = text + " of transactions in zero. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test central_bank__clear_accounts in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a central bank
cb = CentralBank()
cb.identifier = "test_central_bank"
environment.central_bank.append(cb)
#
# TESTING
#
account = 0.0
tranx = 0
for transaction in cb.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
cb.add_transaction("deposits", "", "test_household",
cb.identifier, 0.0, 0.09, 0, -1, environment)
cb.add_transaction("deposits", "", "test_household",
cb.identifier, 20.0, 0.09, 0, -1, environment)
account = 0.0
tranx = 0
for transaction in cb.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
cb.clear_accounts()
account = 0.0
tranx = 0
for transaction in cb.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
def bank__get_account_num_transactions(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.get_account_num_transactions \n"
text = text + " The purpose of this method is to count the numbers of transaction for \n"
text = text + " accounts banks hold. Our standard bank has 3 transactions by default. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__get_account_num_transactions in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
num_transactions = 0.0 # counting all types in account together
print(bank)
# and checking if the number of transaction
# is increasing by one
for type in ["deposits", "cash", "loans"]:
if type == "deposits":
num_transactions = num_transactions + bank.get_account_num_transactions(type)
print("D = " + str(num_transactions))
if type == "cash":
num_transactions = num_transactions + bank.get_account_num_transactions(type)
print("D+M = " + str(num_transactions))
if type == "loans":
num_transactions = num_transactions + bank.get_account_num_transactions(type)
print("D+M+L = " + str(num_transactions))
def updater__accrue_interests(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
from src.updater import Updater
text = "This test checks updater.accrue_interests \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test updater__accrue_interests in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
bank.interest_rate_deposits = 0.05
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
model = Updater(environment)
model.__init__(environment)
environment.new_transaction(
"deposits", "",
environment.get_agent_by_id("test_household").identifier,
environment.get_agent_by_id("test_bank"), 10.0,
environment.get_agent_by_id("test_bank").interest_rate_deposits, 0,
-1)
print(environment.get_agent_by_id("test_household"))
print("Accruing interests\n")
model.accrue_interests(environment, 0)
print(environment.get_agent_by_id("test_household"))
def bank__add_transaction(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.add_transaction \n"
text = text + " The most simple way to test this function is to assign an new \n"
text = text + " transaction to our bank. Therefore, lets just assign the following \n"
text = text + " transaction and check whether it has been added: \n"
text = text + ' (type = "deposits", fromID = -1, toID = bank.identifier, amount = 10, \n'
text = text + " interest = 0.09, maturity = 0, timeOfDefault = -1) \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__add_transaction in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
print(bank)
print("Adding new transaction: \n")
print(environment.get_agent_by_id(bank.identifier))
bank.add_transaction("deposits", "", "test_household",
bank.identifier, 10, 0.09, 0, -1, environment)
# environment.households[0:1][0] is only for testing purposes DO NOT USE IN PRODUCTION
# what it does is is takes the first household in environment, but if there are no
# households (which happens in testing) it doesn't break down
print(bank)
def bank__get_account(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.get_account \n"
text = text + " The purpose of this method is to establish an account for our bank which contains \n"
text = text + " all kinds of assets and liabilities. The method simply adds all kinds of assets \n"
text = text + " and stores them in one volume. As our Banks holds 250.0 assets \n"
text = text + " and 250 liabilites the total volume of our account should be 500.0 \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__get_account in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
account = 0.0 # counting all types in account together
print(bank) # and checking how much is the total
# volume of the account
for type in ["deposits", "cash", "loans"]:
if type == "deposits":
account = account + bank.get_account(type)
print("D = " + str(account))
if type == "cash":
account = account + bank.get_account(type)
print("D+M = " + str(account))
if type == "loans":
account = account + bank.get_account(type)
print("D+M+L = " + str(account))
def market__rationing_abstract(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
text = "This test checks market.rationing_abstract \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test market__rationing_abstract in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
def matching_agents_basic(agent_one, agent_two):
import difflib
seq = difflib.SequenceMatcher(a=agent_one.lower(), b=agent_two.lower())
return seq.ratio()
def matching_agents_basic_inv(agent_one, agent_two):
import difflib
seq = difflib.SequenceMatcher(a=agent_one.lower(), b=agent_two.lower())
return 1-seq.quick_ratio()
def allow_match_basic(agent_one, agent_two):
return True
def allow_match_basic(agent_one, agent_two):
if ((agent_one == 'aaaaaa' and agent_two == 'aaaabb') or (agent_one == 'aaaabb' and agent_two == 'aaaaaa')):
return False
else:
return True
market = Market("market")
rationed = market.rationing_abstract([["aaaaaa", 5], ["bbbbbb", 7], ["aaaabb", -3], ["aabbbb", -4]], matching_agents_basic, allow_match_basic)
print("Pairs found through abstract rationing prioritising similar names:")
print(rationed)
rationed = market.rationing_abstract([["aaaaaa", 5], ["bbbbbb", 7], ["aaaabb", -3], ["aabbbb", -4]], matching_agents_basic_inv, allow_match_basic)
print("Pairs found through abstract rationing prioritising dissimilar names:")
print(rationed)
rationed = market.rationing_abstract([["aaaaaa", 5], ["bbbbbb", 7], ["aaaabb", -3], ["aabbbb", -4]], matching_agents_basic_inv, allow_match_basic)
print("Pairs found through abstract rationing prioritising similar names with 'aaaaaa'>'aaaabb' not allowed:")
print(rationed)
def bank__add_transaction(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.add_transaction \n"
text = text + " The most simple way to test this function is to assign an new \n"
text = text + " transaction to our bank. Therefore, lets just assign the following \n"
text = text + " transaction and check whether it has been added: \n"
text = text + ' (type = "deposits", fromID = -1, toID = bank.identifier, amount = 10, \n'
text = text + " interest = 0.09, maturity = 0, timeOfDefault = -1) \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__add_transaction in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
print(bank)
print("Adding new transaction: \n")
print(environment.get_agent_by_id(bank.identifier))
bank.add_transaction("deposits", "", "test_household",
bank.identifier, 10, 0.09, 0, -1, environment)
# environment.households[0:1][0] is only for testing purposes DO NOT USE IN PRODUCTION
# what it does is is takes the first household in environment, but if there are no
# households (which happens in testing) it doesn't break down
print(bank)
def market__rationing_abstract(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment
from src.transaction import Transaction
from src.market import Market
text = "This test checks market.rationing_abstract \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log",
level=logging.INFO)
logging.info(
'START logging for test market__rationing_abstract in run: %s',
environment_directory + identifier + ".xml")
# Construct household filename
environment = Environment(environment_directory, identifier)
# generate a bank
bank = Bank()
bank.identifier = "test_bank"
environment.banks.append(bank)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
#
# TESTING
#
def matching_agents_basic(agent_one, agent_two):
import difflib
seq = difflib.SequenceMatcher(a=agent_one.lower(),
b=agent_two.lower())
return seq.ratio()
def matching_agents_basic_inv(agent_one, agent_two):
import difflib
seq = difflib.SequenceMatcher(a=agent_one.lower(),
b=agent_two.lower())
return 1 - seq.quick_ratio()
def allow_match_basic(agent_one, agent_two):
return True
def allow_match_basic(agent_one, agent_two):
if ((agent_one == 'aaaaaa' and agent_two == 'aaaabb')
or (agent_one == 'aaaabb' and agent_two == 'aaaaaa')):
return False
else:
return True
market = Market("market")
rationed = market.rationing_abstract(
[["aaaaaa", 5], ["bbbbbb", 7], ["aaaabb", -3], ["aabbbb", -4]],
matching_agents_basic, allow_match_basic)
print(
"Pairs found through abstract rationing prioritising similar names:"
)
print(rationed)
rationed = market.rationing_abstract(
[["aaaaaa", 5], ["bbbbbb", 7], ["aaaabb", -3], ["aabbbb", -4]],
matching_agents_basic_inv, allow_match_basic)
print(
"Pairs found through abstract rationing prioritising dissimilar names:"
)
print(rationed)
rationed = market.rationing_abstract(
[["aaaaaa", 5], ["bbbbbb", 7], ["aaaabb", -3], ["aabbbb", -4]],
matching_agents_basic_inv, allow_match_basic)
print(
"Pairs found through abstract rationing prioritising similar names with 'aaaaaa'>'aaaabb' not allowed:"
)
print(rationed)
def bank__purge_accounts(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.purge_accounts \n"
text = text + " Checking if after the purge_accounts the total amount \n"
text = text + " of transactions in the bank stays the same. \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__purge_accounts in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.network.transactions.add_node(household.identifier)
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.network.transactions.add_node(firm.identifier)
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
environment.network.transactions.add_node(bank.identifier)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
bank.add_transaction("deposits", "", environment.get_agent_by_id("test_household"),
bank.identifier, 0.0, 0.09, 0, -1, environment)
# environment.households[0:1][0] is only for testing purposes DO NOT USE IN PRODUCTION
# what it does is is takes the first household in environment, but if there are no
# households (which happens in testing) it doesn't break down
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
bank.accounts[0].purge_accounts(environment)
account = 0.0
tranx = 0
for transaction in bank.accounts:
account = account + transaction.amount
tranx = tranx + 1
print(tranx)
print(account)
def bank__get_account(self, args):
import os
from src.bank import Bank
from src.household import Household
from src.firm import Firm
from src.environment import Environment # needed for the bankDirectory
text = "This test checks bank.get_account \n"
text = text + " The purpose of this method is to establish an account for our bank which contains \n"
text = text + " all kinds of assets and liabilities. The method simply adds all kinds of assets \n"
text = text + " and stores them in one volume. As our Banks holds 250.0 assets \n"
text = text + " and 250 liabilites the total volume of our account should be 500.0 \n"
self.print_info(text)
#
# INITIALIZATION
#
environment_directory = str(args[0])
identifier = str(args[1])
log_directory = str(args[2])
# Configure logging parameters so we get output while the program runs
logging.basicConfig(format='%(asctime)s %(message)s', datefmt='%m/%d/%Y %H:%M:%S',
filename=log_directory + identifier + ".log", level=logging.INFO)
logging.info('START logging for test bank__get_account in run: %s',
environment_directory + identifier + ".xml")
# Construct bank filename
environment = Environment(environment_directory, identifier)
# get the bank_directory from the environment
bank_directory = environment.bank_directory
# and loop over all banks in the directory
listing = os.listdir(bank_directory)
bank_filename = bank_directory + listing[0]
# generate a household
household = Household()
household.identifier = "test_household"
environment.households.append(household)
# generate a firm
firm = Firm()
firm.identifier = "test_firm"
environment.firms.append(firm)
# generate the bank
bank = Bank()
environment.banks.append(bank)
helper = Helper()
helper.initialize_standard_bank(bank, environment)
#
# TESTING
#
account = 0.0 # counting all types in account together
print(bank) # and checking how much is the total
# volume of the account
for type in ["deposits", "cash", "loans"]:
if type == "deposits":
account = account + bank.get_account(type)
print("D = " + str(account))
if type == "cash":
account = account + bank.get_account(type)
print("D+M = " + str(account))
if type == "loans":
account = account + bank.get_account(type)
print("D+M+L = " + str(account))
