def firm__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 firm.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 firm__get_parameters_from_file in run: %s', environment_directory + identifier + ".xml") # Construct firm filename environment = Environment(environment_directory, identifier) # get the firm_directory from the environment firm_directory = environment.firm_directory # and loop over all firms in the directory listing = os.listdir(firm_directory) firmFilename = firm_directory + listing[0] # generate a household household = Household() household.identifier = "test_household" environment.households.append(household) # generate a bank bank = Bank() bank.identifier = "test_bank" environment.banks.append(bank) # generate a firm firm = Firm() environment.firms.append(firm) helper = Helper() helper.initialize_standard_firm(firm, environment) firm.get_parameters_from_file(firmFilename, environment) # # TESTING # # test whether the parameters are read properly text = "Identifier has been read as follows: \n" text = text + "Identifier: " text = text + firm.identifier text = text + "\n" text = text + "Productivity: " text = text + str(firm.parameters["productivity"]) self.print_info(text)
def firm__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 firm.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 firm__get_transactions_from_file in run: %s', environment_directory + identifier + ".xml") # Construct firm filename environment = Environment(environment_directory, identifier) # get the firm_directory from the environment firm_directory = environment.firm_directory # and loop over all firms in the directory listing = os.listdir(firm_directory) firmFilename = firm_directory + listing[0] # generate a household household = Household() household.identifier = "test_household" environment.households.append(household) # generate a bank bank = Bank() bank.identifier = "test_bank" environment.banks.append(bank) # generate a firm firm = Firm() environment.firms.append(firm) # # TESTING # environment.firms[0].clear_accounts() print("Printing firm:\n") print(environment.firms[0]) print("Reading transactions from the config file.\n") print("Printing firm: \n") firm.get_transactions_from_file(firm_directory + listing[0], environment) print(environment.firms[0])
def firm__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 firm.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 firm__set_parameters in run: %s', environment_directory + identifier + ".xml") # Construct firm filename environment = Environment(environment_directory, identifier) # get the firm_directory from the environment firm_directory = environment.firm_directory # and loop over all firms in the directory listing = os.listdir(firm_directory) firmFilename = firm_directory + listing[0] # generate a household household = Household() household.identifier = "test_household" environment.households.append(household) # generate a bank bank = Bank() bank.identifier = "test_bank" environment.banks.append(bank) # generate a firm firm = Firm() environment.firms.append(firm) helper = Helper() helper.initialize_standard_firm(firm, environment) # # TESTING # text = "Original parameters:" print(text) print(firm.get_parameters()) text = "New parameters:" print(text) firm.set_parameters({'productivity': 1.55, 'active': 1}) print(firm.get_parameters())
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 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 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__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 bank.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 bank__set_identifier 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 identifier: " text = text + bank.get_identifier() print(text) bank.set_identifier("new_ident") text = "New identifier: " text = text + bank.get_identifier() print(text)
def firm__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 firm.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 firm__set_state_variables in run: %s', environment_directory + identifier + ".xml") # Construct firm filename environment = Environment(environment_directory, identifier) # get the firm_directory from the environment firm_directory = environment.firm_directory # and loop over all firms in the directory listing = os.listdir(firm_directory) firmFilename = firm_directory + listing[0] # generate a household household = Household() household.identifier = "test_household" environment.households.append(household) # generate a bank bank = Bank() bank.identifier = "test_bank" environment.banks.append(bank) # # TESTING # # generate a firm firm = Firm() environment.firms.append(firm) helper = Helper() helper.initialize_standard_firm(firm, environment) text = "Original state variables:" print(text) print(firm.get_state_variables()) text = "New state variables:" print(text) firm.set_state_variables({'test': 0.66}) print(firm.get_state_variables())
def bank__get_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.get_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__get_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 = "State variables:" print(text) print(bank.get_state_variables())
def bank__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 bank.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 bank__get_parameters_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() environment.households.append(household) # generate a firm firm = Firm() environment.firms.append(firm) # generate the bank bank = Bank() environment.banks.append(bank) bank.get_parameters_from_file(bank_filename, environment) # # TESTING # # test whether the parameters are read properly text = "Identifier has been read as follows: \n" text = text + "Identifier: " text = text + bank.identifier text = text + "\n" self.print_info(text)
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 firm__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 firm.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 firm__get_transactions_from_file in run: %s', environment_directory + identifier + ".xml") # Construct firm filename environment = Environment(environment_directory, identifier) # get the firm_directory from the environment firm_directory = environment.firm_directory # and loop over all firms in the directory listing = os.listdir(firm_directory) firmFilename = firm_directory + listing[0] # generate a household household = Household() household.identifier = "test_household" environment.households.append(household) # generate a bank bank = Bank() bank.identifier = "test_bank" environment.banks.append(bank) # generate a firm firm = Firm() environment.firms.append(firm) # # TESTING # environment.firms[0].clear_accounts() print("Printing firm:\n") print(environment.firms[0]) print("Reading transactions from the config file.\n") print("Printing firm: \n") firm.get_transactions_from_file(firm_directory + listing[0], environment) print(environment.firms[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 household__getattr(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.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 household__getattr 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 # print('Accessing rates through household.parameters["propensity_to_save"] :') print(household.parameters["propensity_to_save"]) print("Accessing rates through household.propensity_to_save:") print(household.propensity_to_save)
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 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 helper__initialize_standard_household(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_household \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_household 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_household(household, environment) print("Initialized standard household") print(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 initialize_banks_from_files(self, bankDirectory, state, time): from src.bank import Bank # this routine is called more than once, so we have to reset the list of banks each time self.banks = [] listing = os.listdir(bankDirectory) if (len(listing) != self.static_parameters["numBanks"]): logging.error(" ERROR: number of configuration files in %s (=%s) does not match numBanks (=%s)", bankDirectory, str(len(listing)), str(self.static_parameters["numBanks"])) for infile in listing: bank = Bank() bank.get_parameters_from_file(bankDirectory + infile, self.get_state(0), self.static_parameters["numBanks"], time) self.banks.append(bank) bank.__del__() # TODO not sure if this is really safe, but it is better than doing nothing about all those created instances...
def helper__initialize_standard_household(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_household \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_household 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_household(household, environment) print("Initialized standard household") print(household)
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 initialize_banks_from_files(self, bank_directory): from src.bank import Bank # this routine is called more than once, so we have to reset the list of banks each time self.banks = [] # we list all the files in the specified directory listing = os.listdir(bank_directory) # and check if the number of files is in line with the parameters if (len(listing) != self.num_banks): logging.error(" ERROR: number of configuration files in %s (=%s) does not match num_banks (=%s)", bank_directory, str(len(listing)), str(self.num_banks)) # we read the files sequentially for infile in listing: bank = Bank() bank.get_parameters_from_file(bank_directory + infile, self) # and read parameters to the banks, only to add them to the environment self.banks.append(bank)
class BankingOps(object): def __init__(self, initial_balance): self.bank = Bank(initial_balance) def addCustomerPanel(self, name, initial_deposit): customer = Customer(name) cash = float(initial_deposit) return self.bank.enroll_customer(customer, cash) def withdrawAmountCustomer(self, name, amount): amount = float(amount) customer = Customer(name) return customer.withdraw(amount, self.bank) def depositAmountCustomer(self, name, amount): amount = float(amount) customer = Customer(name) return customer.deposit(amount, self.bank) def print_bank_details(self): self.bank.pretty_print_customers()
def environment__check_agent_homogeneity(self, args): import os from src.bank import Bank from src.household import Household from src.firm import Firm from src.environment import Environment text = "This test checks environment.check_agent_homogeneity \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 environment__check_agent_homogeneity in run: %s', environment_directory + identifier + ".xml") # Construct household filename environment = Environment(environment_directory, identifier) # # TESTING # bank = Bank() bank.identifier = "new bank" environment.banks.append(bank) environment.agents = [environment.banks, environment.firms, environment.households] print("Are banks homogeneous?") print(environment.check_agent_homogeneity("banks")) print("Changing one of the banks...") environment.get_agent_by_id("new bank").parameters["active"] = 4 print("Are banks homogeneous?") print(environment.check_agent_homogeneity("banks"))
def initialize_banks_from_files(self, bankDirectory, state, time): # this routine is called more than once, so we have to reset the list of banks each time self.banks = [] listing = os.listdir(bankDirectory) # print('listing', listing) if len(listing) != self.parameters.numBanks: logging.error(" ERROR: number of configuration files in %s (=%s) does not match numBanks (=%s)", bankDirectory, str(len(listing)), str(self.parameters.numBanks)) for infile in listing: # print("infile", infile) bank = Bank() bank.get_parameters_from_file(bankDirectory + infile, self.get_state(0), self.parameters.numBanks, time) # print("bank", bank) self.banks.append(bank) bank.__del__() # TODO not sure if this is really safe, but it is better than doing nothing about all those created instances...
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__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 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 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 test_create_new_bank(): b = Bank('Chase') assert b.name == 'Chase' assert len(b.clients) == 0
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)
import pandas as pd from datetime import date from datetime import datetime import src.utils as utils from src.user import User from src.bank import Bank from src.account import Account, AccountType from src.transaction import Transaction, TransactionType # create a bank with users you can play around with bank = Bank() df = pd.read_csv('data/users.csv') for index, row in df.iterrows(): sec_qs = { row.security_question_1: row.security_answer_1, row.security_question_2: row.security_answer_2, row.security_question_3: row.security_answer_3 } dt = datetime.combine(pd.Timestamp(row.dob).date(), datetime.min.time()) bank.add_user(User(row.username, row.password, row['name'], dt, row.address, sec_qs)) # You can assume that the code above is correct. # Use the space below to test out any functions or pieces of code. user = User("Huang", "123456", "Zean", datetime.now(), "Qingdao", { "favoriteFood": "Apple", "Parent": "Mother", "Sports": "Basketball"})
def firm__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 firm.add_transaction \n" text = text + " The most simple way to test this function is to assign an new \n" text = text + " transaction to our firm. 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 = firm.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 firm__add_transaction in run: %s', environment_directory + identifier + ".xml") # Construct firm filename environment = Environment(environment_directory, identifier) # get the firm_directory from the environment firm_directory = environment.firm_directory # and loop over all firms in the directory listing = os.listdir(firm_directory) firmFilename = firm_directory + listing[0] # generate a household household = Household() household.identifier = "test_household" environment.households.append(household) # generate a bank bank = Bank() bank.identifier = "test_bank" environment.banks.append(bank) # generate a firm firm = Firm() environment.firms.append(firm) helper = Helper() helper.initialize_standard_firm(firm, environment) # # TESTING # print(firm) print("Adding new transaction: \n") firm.add_transaction("deposits", "", environment.households[0:1][0], firm.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(firm)
def firm__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 firm.get_account_num_transactions \n" text = text + " The purpose of this method is to count the numbers of transaction for \n" text = text + " accounts firms hold. Our standard frm 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 firm__get_account_num_transactions in run: %s', environment_directory + identifier + ".xml") # Construct firm filename environment = Environment(environment_directory, identifier) # get the firm_directory from the environment firm_directory = environment.firm_directory # and loop over all firms in the directory listing = os.listdir(firm_directory) firmFilename = firm_directory + listing[0] # generate a household household = Household() household.identifier = "test_household" environment.households.append(household) # generate a bank bank = Bank() bank.identifier = "test_bank" environment.banks.append(bank) # generate a firm firm = Firm() environment.firms.append(firm) helper = Helper() helper.initialize_standard_firm(firm, environment) # # TESTING # num_transactions = 0.0 # counting all types in account together print(firm) # and checking if the number of transaction # is increasing by one for type in ["loans", "cash", "goods"]: if type == "loans": num_transactions = num_transactions + firm.get_account_num_transactions(type) print("L = " + str(num_transactions)) if type == "cash": num_transactions = num_transactions + firm.get_account_num_transactions(type) print("L+M = " + str(num_transactions)) if type == "goods": num_transactions = num_transactions + firm.get_account_num_transactions(type) print("L+M+G = " + str(num_transactions))
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__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() account = 0.0 tranx = 0 for transaction in bank.accounts: account = account + transaction.amount tranx = tranx + 1 print(tranx) print(account)
def __init__(self, initial_balance): self.bank = Bank(initial_balance)
def firm__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 firm.get_account \n" text = text + " The purpose of this method is to establish an account for our firm 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 firms 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 firm__get_account in run: %s', environment_directory + identifier + ".xml") # Construct firm filename environment = Environment(environment_directory, identifier) # get the firm_directory from the environment firm_directory = environment.firm_directory # and loop over all firms in the directory listing = os.listdir(firm_directory) firmFilename = firm_directory + listing[0] # generate a household household = Household() household.identifier = "test_household" environment.households.append(household) # generate a bank bank = Bank() bank.identifier = "test_bank" environment.banks.append(bank) # generate a firm firm = Firm() environment.firms.append(firm) helper = Helper() helper.initialize_standard_firm(firm, environment) # # TESTING # account = 0.0 # counting all types in account together print(firm) # and checking how much is the total # volume of the account for type in ["loans", "cash", "goods"]: if type == "loans": account = account + firm.get_account(type) print("L = " + str(account)) if type == "cash": account = account + firm.get_account(type) print("L+M = " + str(account)) if type == "goods": account = account + firm.get_account(type) print("L+M+G = " + str(account))
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__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 central_bank__get_account_num_transactions(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_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 central 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 central_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 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) num_transactions = 0.0 # counting all types in account together print(cb) # and checking if the number of transaction # is increasing by one for type in ["deposits", "cash", "loans"]: if type == "deposits": num_transactions = num_transactions + cb.get_account_num_transactions(type) print("D = " + str(num_transactions)) if type == "cash": num_transactions = num_transactions + cb.get_account_num_transactions(type) print("D+M = " + str(num_transactions)) if type == "loans": num_transactions = num_transactions + cb.get_account_num_transactions(type) print("D+M+L = " + str(num_transactions))
def firm__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 firm.purge_accounts \n" text = text + " Checking if after the purge_accounts the total amount \n" text = text + " of transactions in the firm 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 firm__purge_accounts in run: %s', environment_directory + identifier + ".xml") # Construct firm filename environment = Environment(environment_directory, identifier) # get the firm_directory from the environment firm_directory = environment.firm_directory # and loop over all firms in the directory listing = os.listdir(firm_directory) firmFilename = firm_directory + listing[0] # generate a household household = Household() household.identifier = "test_household" environment.households.append(household) # generate a bank bank = Bank() bank.identifier = "test_bank" environment.banks.append(bank) # generate a firm firm = Firm() environment.firms.append(firm) helper = Helper() helper.initialize_standard_firm(firm, environment) # # TESTING # account = 0.0 tranx = 0 for transaction in firm.accounts: account = account + transaction.amount tranx = tranx + 1 print(tranx) print(account) firm.add_transaction("deposits", "", environment.households[0:1][0], firm.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 firm.accounts: account = account + transaction.amount tranx = tranx + 1 print(tranx) print(account) firm.accounts[0].purge_accounts(environment) account = 0.0 tranx = 0 for transaction in firm.accounts: account = account + transaction.amount tranx = tranx + 1 print(tranx) print(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)