def endow_labour(self, environment, time): # We make sure household get their labour endowment per step for household in environment.households: # First, we set a control variable that makes sure we have exactly # one transaction with "manhours", though this should in general # be the case, this should always run through the second if check = 0 for tranx in household.accounts: if tranx.type_ == "manhours": check = check + 1 # We check how many transactions with manhours are there for the household # If there are no "manhours" transactions then we create one and add it to the household's accounts if check == 0: # The amount is equal to the parameter read from the config of the household amount = household.labour # We create the transaction transaction = Transaction() # We add the appropriate values to the transaction transaction.this_transaction("manhours", "", household.identifier, household.identifier, amount, 0, 0, -1) # It's important to add the transaction using the method # from Transaction class and not manually transaction.add_transaction(environment) else: # If we have more than one "mahhours" transaction we raise an error raise LookupError("Labour transactions for a household haven't been properly removed.") logging.info(" labour endowed on step: %s", time)
def new_transaction(self, type_, asset, from_, to, amount, interest, maturity, time_of_default): from src.transaction import Transaction transaction = Transaction() transaction.this_transaction(type_, asset, from_, to, amount, interest, maturity, time_of_default) transaction.add_transaction(self)
def make_deposits(self, environment, time): for household in environment.households: cash = 0.0 # total of cash available for the household control_deposits = 0 # checking if the household already has deposits # We calculate the available cash for tranx in household.accounts: if tranx.type_ == "cash": cash = cash + tranx.amount tranx.amount = 0 # And the number of existing deposits if tranx.type_ == "deposits": control_deposits = control_deposits + 1 # And move all available cash to deposits at the end of the step # If there are no deposits we create one in a bank # The bank is chosen randomly if control_deposits == 0: # We choose a bank randomly random_bank = random.choice(environment.banks) # Create a transaction transaction = Transaction() # Add the appropriate values to the transaction transaction.this_transaction("deposits", "", household.identifier, random_bank, amount, random_bank.interest_rate_deposits, 0, -1) # And add the transaction to the books (do it through function/not manually) transaction.add_transaction(environment) # If there are previous deposits we expand them linearly else: for tranx in household.accounts: if tranx.type_ == "deposits": # We add the remaining cash to the existing deposits # in equal proportions # Perhaps this can be done proportionate with regards # to the value of these deposits, but it's minor at this point tranx.amount = tranx.amount + (cash/control_deposits) logging.info(" deposits made on step: %s", time)
def add_transaction(self, type_, asset, from_id, to_id, amount, interest, maturity, time_of_default, environment): from src.transaction import Transaction transaction = Transaction() transaction.this_transaction(type_, asset, from_id, to_id, amount, interest, maturity, time_of_default) transaction.add_transaction(environment)
def endow_labour(self, environment, time): # We make sure household get their labour endowment per step for household in environment.households: # First, we set a control variable that makes sure we have exactly # one transaction with "manhours", though this should in general # be the case, this should always run through the second if check = 0 for tranx in household.accounts: if tranx.type_ == "manhours": check = check + 1 # We check how many transactions with manhours are there for the household # If there are no "manhours" transactions then we create one and add it to the household's accounts if check == 0: # The amount is equal to the parameter read from the config of the household amount = household.labour # We create the transaction transaction = Transaction() # We add the appropriate values to the transaction transaction.this_transaction("manhours", "", household.identifier, household.identifier, amount, 0, 0, -1) # It's important to add the transaction using the method # from Transaction class and not manually transaction.add_transaction(environment) else: # If we have more than one "mahhours" transaction we raise an error raise LookupError( "Labour transactions for a household haven't been properly removed." ) logging.info(" labour endowed on step: %s", time)
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 network__get_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 from src.transaction import Transaction from src.network import Network text = "This test checks network.get_transactions \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 network__get_transactions in run: %s', environment_directory + identifier + ".xml") # Construct household filename environment = Environment(environment_directory, identifier) # # TESTING # print(nx.info(environment.network.get_transactions())) print("Adding a transaction") transaction = Transaction() transaction.add_transaction("type", "asset", "bank_test_config_id", "bank_test_config_id_two", 1, 2, 3, 4, environment) print(nx.info(environment.network.get_transactions()))
def initialize_standard_household(self, household, environment): from src.transaction import Transaction household.identifier = "standard_household_id" # identifier household.parameters["labour"] = 24.00 # labour to sell per step household.parameters["propensity_to_save"] = 0.40 # propensity to save # percentage of income household wants to save as deposits # deposits - we get the first bank from the list of banks # if there are no banks it will be a blank which is fine for testing amount = 200.0 transaction = Transaction() transaction.this_transaction("deposits", "", household.identifier, environment.banks[0].identifier, amount, environment.banks[0].interest_rate_deposits, 0, -1) # environment.banks[0] is only for testing purposes DO NOT USE IN PRODUCTION transaction.add_transaction(environment) # money - cash and equivalents amount = 50.0 transaction = Transaction() transaction.this_transaction("cash", "", household.identifier, household.identifier, amount, 0, 0, -1) transaction.add_transaction(environment) # manhours - labour to sell amount = 250.0 transaction = Transaction() transaction.this_transaction("manhours", "", household.identifier, household.identifier, amount, 0, 0, -1) transaction.add_transaction(environment)
def initialize_standard_firm(self, firm, environment): from src.transaction import Transaction firm.identifier = "standard_firm_id" # identifier firm.parameters[ "productivity"] = 1.20 # how much goods do we get from 1 unit of labour # loans - we get the first bank from the list of banks # if there are no banks it will be a blank which is fine for testing amount = 250.0 transaction = Transaction() transaction.this_transaction("loans", "", environment.banks[0].identifier, firm.identifier, amount, environment.banks[0].interest_rate_loans, 0, -1) # environment.banks[0] is only for testing purposes DO NOT USE IN PRODUCTION transaction.add_transaction(environment) # money - cash and equivalents amount = 200.0 transaction = Transaction() transaction.this_transaction("cash", "", firm.identifier, firm.identifier, amount, 0, 0, -1) transaction.add_transaction(environment) # goods - unique production amount = 50.0 transaction = Transaction() transaction.this_transaction("goods", "", firm.identifier, firm.identifier, amount, 0, 0, -1) transaction.add_transaction(environment)
def initialize_standard_bank(self, bank, environment): from src.transaction import Transaction bank.identifier = "standard_bank_id" # deposits - we get the first household from the list of households # if there are no households it will be a blank which is fine for testing amount = 250.0 transaction = Transaction() transaction.this_transaction("deposits", "", environment.households[0].identifier, bank.identifier, amount, bank.interest_rate_deposits, 0, -1) # environment.households[0] is only for testing purposes DO NOT USE IN PRODUCTION transaction.add_transaction(environment) # money - cash and equivalents amount = 100.0 transaction = Transaction() transaction.this_transaction("cash", "", bank.identifier, bank.identifier, amount, 0, 0, -1) transaction.add_transaction(environment) # loans - we get the first firm from the list of firms # if there are no firms it will be a blank which is fine for testing amount = 150.0 transaction = Transaction() transaction.this_transaction("loans", "", bank.identifier, environment.firms[0].identifier, amount, bank.interest_rate_loans, 0, -1) # environment.firms[0] is only for testing purposes DO NOT USE IN PRODUCTION transaction.add_transaction(environment)
def initialize_standard_household(self, household, environment): from src.transaction import Transaction household.identifier = "standard_household_id" # identifier household.parameters["labour"] = 24.00 # labour to sell per step household.parameters["propensity_to_save"] = 0.40 # propensity to save # percentage of income household wants to save as deposits # deposits - we get the first bank from the list of banks # if there are no banks it will be a blank which is fine for testing amount = 200.0 transaction = Transaction() transaction.this_transaction( "deposits", "", household.identifier, environment.banks[0].identifier, amount, environment.banks[0].interest_rate_deposits, 0, -1) # environment.banks[0] is only for testing purposes DO NOT USE IN PRODUCTION transaction.add_transaction(environment) # money - cash and equivalents amount = 50.0 transaction = Transaction() transaction.this_transaction("cash", "", household.identifier, household.identifier, amount, 0, 0, -1) transaction.add_transaction(environment) # manhours - labour to sell amount = 250.0 transaction = Transaction() transaction.this_transaction("manhours", "", household.identifier, household.identifier, amount, 0, 0, -1) transaction.add_transaction(environment)
def initialize_standard_firm(self, firm, environment): from src.transaction import Transaction firm.identifier = "standard_firm_id" # identifier firm.parameters["productivity"] = 1.20 # how much goods do we get from 1 unit of labour # loans - we get the first bank from the list of banks # if there are no banks it will be a blank which is fine for testing amount = 250.0 transaction = Transaction() transaction.this_transaction( "loans", "", environment.banks[0].identifier, firm.identifier, amount, environment.banks[0].interest_rate_loans, 0, -1, ) # environment.banks[0] is only for testing purposes DO NOT USE IN PRODUCTION transaction.add_transaction(environment) # money - cash and equivalents amount = 200.0 transaction = Transaction() transaction.this_transaction("cash", "", firm.identifier, firm.identifier, amount, 0, 0, -1) transaction.add_transaction(environment) # goods - unique production amount = 50.0 transaction = Transaction() transaction.this_transaction("goods", "", firm.identifier, firm.identifier, amount, 0, 0, -1) transaction.add_transaction(environment)
def initialize_standard_bank(self, bank, environment): from src.transaction import Transaction bank.identifier = "standard_bank_id" # deposits - we get the first household from the list of households # if there are no households it will be a blank which is fine for testing amount = 250.0 transaction = Transaction() transaction.this_transaction("deposits", "", environment.households[0].identifier, bank.identifier, amount, bank.interest_rate_deposits, 0, -1) # environment.households[0] is only for testing purposes DO NOT USE IN PRODUCTION transaction.add_transaction(environment) # money - cash and equivalents amount = 100.0 transaction = Transaction() transaction.this_transaction("cash", "", bank.identifier, bank.identifier, amount, 0, 0, -1) transaction.add_transaction(environment) # loans - we get the first firm from the list of firms # if there are no firms it will be a blank which is fine for testing amount = 150.0 transaction = Transaction() transaction.this_transaction("loans", "", bank.identifier, environment.firms[0].identifier, amount, bank.interest_rate_loans, 0, -1) # environment.firms[0] is only for testing purposes DO NOT USE IN PRODUCTION transaction.add_transaction(environment)
def produce(self, environment, time): # We take all the labour and turn it into goods for firm in environment.firms: # We do it for every firm production_factors = 0 # Here, we count how much labour the firm has for tranx in firm.accounts: if tranx.type_ == "manhours": # We move the labour to production as a production factor # First, we move it to production factors used below # Then we will remove it from the books production_factors = production_factors + tranx.amount # Amount produced is labour * productivity in this simple model amount = production_factors * firm.productivity # Create a transaction transaction = Transaction() # Add the appropriate values to the transaction transaction.this_transaction("goods", "", firm.identifier, firm.identifier, amount, 0, 0, -1) # And add the transaction to the books (do it through function/not manually) transaction.add_transaction(environment) # Finally, we remove all the labour that was used in production # from the books of the firms self.remove_labour_firms(environment, time) logging.info(" goods produced on step: %s", time)
def produce(self, environment, time): # We take all the labour and turn it into goods for firm in environment.firms: # We do it for every firm production_factors = 0 # Here, we count how much labour the firm has for tranx in firm.accounts: if tranx.type_ == "manhours": # We move the labour to production as a production factor # First, we move it to production factors used below # Then we will remove it from the books production_factors = production_factors + tranx.amount # Amount produced is labour * productivity in this simple model amount = production_factors * firm.productivity # Create a transaction transaction = Transaction() # Add the appropriate values to the transaction transaction.this_transaction("goods", "", firm.identifier, firm.identifier, amount, 0, 0, -1) # And add the transaction to the books (do it through function/not manually) transaction.add_transaction(environment) # Finally, we remove all the labour that was used in production # from the books of the firms self.remove_labour_firms(environment, time) logging.info(" goods produced on step: %s", time)
def make_deposits(self, environment, time): for household in environment.households: cash = 0.0 # total of cash available for the household control_deposits = 0 # checking if the household already has deposits # We calculate the available cash for tranx in household.accounts: if tranx.type_ == "cash": cash = cash + tranx.amount tranx.amount = 0 # And the number of existing deposits if tranx.type_ == "deposits": control_deposits = control_deposits + 1 # And move all available cash to deposits at the end of the step # If there are no deposits we create one in a bank # The bank is chosen randomly if control_deposits == 0: # We choose a bank randomly random_bank = random.choice(environment.banks) # Create a transaction transaction = Transaction() # Add the appropriate values to the transaction transaction.this_transaction( "deposits", "", household.identifier, random_bank, amount, random_bank.interest_rate_deposits, 0, -1) # And add the transaction to the books (do it through function/not manually) transaction.add_transaction(environment) # If there are previous deposits we expand them linearly else: for tranx in household.accounts: if tranx.type_ == "deposits": # We add the remaining cash to the existing deposits # in equal proportions # Perhaps this can be done proportionate with regards # to the value of these deposits, but it's minor at this point tranx.amount = tranx.amount + (cash / control_deposits) logging.info(" deposits made on step: %s", time)
def sell_labour(self, environment, time): # We want the sell to be done in random pairs # So we need to randomise the households and the firms # We start with the firms and create a list of order integers # the size of the number of firms itrange = list(range(0, int(environment.num_firms))) # Then we shuffle the list random.shuffle(itrange) # And use it to loop over the firms randomly for i in itrange: # Since we don't loop directly over firms # We assign the correct firm in this run over the loop firm = environment.firms[i] # We calculate the amount of cash firm has to buy labour to_buy = 0.0 # We go through the firm's transactions for tranx in firm.accounts: # If we find cash transaction if tranx.type_ == "cash": # We add the cash to the amount of labour the firm # wants to buy, we assume 1 unit of labour costs 1 unit of cash to_buy = to_buy + tranx.amount # Now we randomise households and create a list of order integers # the size of the number of households itrange_hh = list(range(0, int(environment.num_households))) # Then we shuffle the list random.shuffle(itrange_hh) # For each household in random order for h in itrange_hh: # Since we don't loop directly over households # We assign the correct household in this run over the loop household = environment.households[h] household_cash = 0.0 # We go through household's accounts for tranx in household.accounts: # And find transactions with labour if tranx.type_ == "manhours": # We will sell them for cash # So we look through firm's accounts for tranx_f in firm.accounts: # And find cash transactions if tranx_f.type_ == "cash": # We can only buy the lowest amount from the cash the firm # has, the labour the household has, and however many units # they want to buy amount_proxy = min(tranx.amount, tranx_f.amount, to_buy) # Then we remove the appropriate amount of cash from the firm tranx_f.amount = tranx_f.amount - amount_proxy # Lower the amount firm wants to buy to_buy = to_buy - amount_proxy # And remove the goods from household's account tranx.amount = tranx.amount - amount_proxy # And we note the cash to be added to the household household_cash = household_cash + amount_proxy # Create a transaction transaction = Transaction() # Add the appropriate values to the transaction transaction.this_transaction("manhours", "", firm.identifier, firm.identifier, amount_proxy, 0, 0, -1) # And add the transaction to the books (do it through function/not manually) transaction.add_transaction(environment) # Add cash for sold items to the household cash_number = 0 # We calculate how many cash account the household has for tranx in household.accounts: if tranx.type_ == "cash": cash_number = cash_number + 1 # If there are no cash transactions on the household's books # We create a new one and put the proceeds there if cash_number == 0: # Create a transaction transaction = Transaction() # Add the appropriate values to the transaction transaction.this_transaction("cash", "", household.identifier, household.identifier, household_cash, 0, 0, -1) # And add the transaction to the books (do it through function/not manually) transaction.add_transaction(environment) # If the household has previous cash transactions we add the cash from sales proportionately else: # We find all cash transactions for tranx in household.accounts: if tranx.type_ == "cash": # And add the sales proceeds proportionately tranx.amount = tranx.amount + (household_cash / cash_number) # The sales above may have rendered some transactions worthless # So we need to purge all accounts to make sure everything is in order transaction = Transaction() transaction.purge_accounts(environment) logging.info(" labour sold to firms on step: %s", time)
def consume(self, environment, time): # We want the consumption to be done in random pairs # So we need to randomise the households and the firms # We start with the households and create a list of order integers # the size of the number of households itrange_hh = list(range(0, int(environment.num_households))) # Then we shuffle the list random.shuffle(itrange_hh) # And use it to loop over the households randomly for h in itrange_hh: # Since we don't loop directly over households # We assign the correct household in this run over the loop household = environment.households[h] wealth = 0.0 # total of deposits and cash available for the household cash = 0.0 # total of cash available for the household # We calculate the above two values for tranx in household.accounts: # We add all deposits and all cash to the wealth if tranx.type_ == "deposits" or tranx.type_ == "cash": wealth = wealth + tranx.amount # But only cash to the available cash if tranx.type_ == "cash": cash = cash + tranx.amount # We consume the percentage of wealth determined by # the propensity to save, cash first to_consume = wealth * (1 - household.propensity_to_save) # Now we randomise firms and create a list of order integers # the size of the number of households itrange = list(range(0, int(environment.num_firms))) # Then we shuffle the list random.shuffle(itrange) # For each firm in random order for i in itrange: # For every transaction on that firm's books # We make a proxy for the cash that firm should obtain # for whatever good they've sold to the household firm = environment.firms[i] firm_cash = 0.0 for tranx in firm.accounts: # If the transaction contains goods if tranx.type_ == "goods": # We go through the household's accounts for tranx_h in household.accounts: # And look for cash if tranx_h.type_ == "cash": # We can buy for minimum of the cash and goods # in question amount_proxy = min(tranx.amount, tranx_h.amount, to_consume) # And remove the appropriate amount of cash tranx_h.amount = tranx_h.amount - amount_proxy # Lower the amount household wants to consume to_consume = to_consume - amount_proxy # And remove the goods from firm's account tranx.amount = tranx.amount - amount_proxy # And we note the cash to be added to the firm firm_cash = firm_cash + amount_proxy for tranx_h in household.accounts: # And look for deposits if tranx_h.type_ == "deposits": # We can buy for minimum of the deposits and goods # in question amount_proxy = min(tranx.amount, tranx_h.amount, to_consume) # And remove the appropriate amount of deposits tranx_h.amount = tranx_h.amount - amount_proxy # Lower the amount household wants to consume to_consume = to_consume - amount_proxy # And remove the goods from firm's account tranx.amount = tranx.amount - amount_proxy # And we note the cash to be added to the firm firm_cash = firm_cash + amount_proxy # Add cash for sold items to the firm cash_number = 0 # We calculate how many cash account the firm has for tranx in firm.accounts: if tranx.type_ == "cash": cash_number = cash_number + 1 # If the firm doesn't have any cash accounts we create a new one if cash_number == 0: # Create a transaction transaction = Transaction() # Add the appropriate values to the transaction transaction.this_transaction("cash", "", firm.identifier, firm.identifier, firm_cash, 0, 0, -1) # And add the transaction to the books (do it through function/not manually) transaction.add_transaction(environment) # If the firm has previous cash transactions we add the cash from sales proportionately else: # We find all cash transactions for tranx in firm.accounts: if tranx.type_ == "cash": # And add the sales proceeds proportionately tranx.amount = tranx.amount + (firm_cash / cash_number) # The sales above may have rendered some transactions worthless # So we need to purge all accounts to make sure everything is in order transaction = Transaction() transaction.purge_accounts(environment) # Finally, we remove the goods which weren't sold from firms' accounts # As they are perishable self.remove_goods_firms(environment, time) logging.info(" goods consumed on step: %s", time)
def new_transaction(self, type_, asset, from_, to, amount, interest, maturity, time_of_default): from src.transaction import Transaction transaction = Transaction() transaction.this_transaction(type_, asset, from_, to, amount, interest, maturity, time_of_default) transaction.add_transaction(self)
def sell_labour(self, environment, time): # We want the sell to be done in random pairs # So we need to randomise the households and the firms # We start with the firms and create a list of order integers # the size of the number of firms itrange = list(range(0, int(environment.num_firms))) # Then we shuffle the list random.shuffle(itrange) # And use it to loop over the firms randomly for i in itrange: # Since we don't loop directly over firms # We assign the correct firm in this run over the loop firm = environment.firms[i] # We calculate the amount of cash firm has to buy labour to_buy = 0.0 # We go through the firm's transactions for tranx in firm.accounts: # If we find cash transaction if tranx.type_ == "cash": # We add the cash to the amount of labour the firm # wants to buy, we assume 1 unit of labour costs 1 unit of cash to_buy = to_buy + tranx.amount # Now we randomise households and create a list of order integers # the size of the number of households itrange_hh = list(range(0, int(environment.num_households))) # Then we shuffle the list random.shuffle(itrange_hh) # For each household in random order for h in itrange_hh: # Since we don't loop directly over households # We assign the correct household in this run over the loop household = environment.households[h] household_cash = 0.0 # We go through household's accounts for tranx in household.accounts: # And find transactions with labour if tranx.type_ == "manhours": # We will sell them for cash # So we look through firm's accounts for tranx_f in firm.accounts: # And find cash transactions if tranx_f.type_ == "cash": # We can only buy the lowest amount from the cash the firm # has, the labour the household has, and however many units # they want to buy amount_proxy = min(tranx.amount, tranx_f.amount, to_buy) # Then we remove the appropriate amount of cash from the firm tranx_f.amount = tranx_f.amount - amount_proxy # Lower the amount firm wants to buy to_buy = to_buy - amount_proxy # And remove the goods from household's account tranx.amount = tranx.amount - amount_proxy # And we note the cash to be added to the household household_cash = household_cash + amount_proxy # Create a transaction transaction = Transaction() # Add the appropriate values to the transaction transaction.this_transaction( "manhours", "", firm.identifier, firm.identifier, amount_proxy, 0, 0, -1) # And add the transaction to the books (do it through function/not manually) transaction.add_transaction(environment) # Add cash for sold items to the household cash_number = 0 # We calculate how many cash account the household has for tranx in household.accounts: if tranx.type_ == "cash": cash_number = cash_number + 1 # If there are no cash transactions on the household's books # We create a new one and put the proceeds there if cash_number == 0: # Create a transaction transaction = Transaction() # Add the appropriate values to the transaction transaction.this_transaction("cash", "", household.identifier, household.identifier, household_cash, 0, 0, -1) # And add the transaction to the books (do it through function/not manually) transaction.add_transaction(environment) # If the household has previous cash transactions we add the cash from sales proportionately else: # We find all cash transactions for tranx in household.accounts: if tranx.type_ == "cash": # And add the sales proceeds proportionately tranx.amount = tranx.amount + (household_cash / cash_number) # The sales above may have rendered some transactions worthless # So we need to purge all accounts to make sure everything is in order transaction = Transaction() transaction.purge_accounts(environment) logging.info(" labour sold to firms on step: %s", time)
def add_transaction(self, type_, asset, from_id, to_id, amount, interest, maturity, time_of_default, environment): from src.transaction import Transaction transaction = Transaction() transaction.this_transaction(type_, asset, from_id, to_id, amount, interest, maturity, time_of_default) transaction.add_transaction(environment)
def consume(self, environment, time): # We want the consumption to be done in random pairs # So we need to randomise the households and the firms # We start with the households and create a list of order integers # the size of the number of households itrange_hh = list(range(0, int(environment.num_households))) # Then we shuffle the list random.shuffle(itrange_hh) # And use it to loop over the households randomly for h in itrange_hh: # Since we don't loop directly over households # We assign the correct household in this run over the loop household = environment.households[h] wealth = 0.0 # total of deposits and cash available for the household cash = 0.0 # total of cash available for the household # We calculate the above two values for tranx in household.accounts: # We add all deposits and all cash to the wealth if tranx.type_ == "deposits" or tranx.type_ == "cash": wealth = wealth + tranx.amount # But only cash to the available cash if tranx.type_ == "cash": cash = cash + tranx.amount # We consume the percentage of wealth determined by # the propensity to save, cash first to_consume = wealth * (1 - household.propensity_to_save) # Now we randomise firms and create a list of order integers # the size of the number of households itrange = list(range(0, int(environment.num_firms))) # Then we shuffle the list random.shuffle(itrange) # For each firm in random order for i in itrange: # For every transaction on that firm's books # We make a proxy for the cash that firm should obtain # for whatever good they've sold to the household firm = environment.firms[i] firm_cash = 0.0 for tranx in firm.accounts: # If the transaction contains goods if tranx.type_ == "goods": # We go through the household's accounts for tranx_h in household.accounts: # And look for cash if tranx_h.type_ == "cash": # We can buy for minimum of the cash and goods # in question amount_proxy = min(tranx.amount, tranx_h.amount, to_consume) # And remove the appropriate amount of cash tranx_h.amount = tranx_h.amount - amount_proxy # Lower the amount household wants to consume to_consume = to_consume - amount_proxy # And remove the goods from firm's account tranx.amount = tranx.amount - amount_proxy # And we note the cash to be added to the firm firm_cash = firm_cash + amount_proxy for tranx_h in household.accounts: # And look for deposits if tranx_h.type_ == "deposits": # We can buy for minimum of the deposits and goods # in question amount_proxy = min(tranx.amount, tranx_h.amount, to_consume) # And remove the appropriate amount of deposits tranx_h.amount = tranx_h.amount - amount_proxy # Lower the amount household wants to consume to_consume = to_consume - amount_proxy # And remove the goods from firm's account tranx.amount = tranx.amount - amount_proxy # And we note the cash to be added to the firm firm_cash = firm_cash + amount_proxy # Add cash for sold items to the firm cash_number = 0 # We calculate how many cash account the firm has for tranx in firm.accounts: if tranx.type_ == "cash": cash_number = cash_number + 1 # If the firm doesn't have any cash accounts we create a new one if cash_number == 0: # Create a transaction transaction = Transaction() # Add the appropriate values to the transaction transaction.this_transaction("cash", "", firm.identifier, firm.identifier, firm_cash, 0, 0, -1) # And add the transaction to the books (do it through function/not manually) transaction.add_transaction(environment) # If the firm has previous cash transactions we add the cash from sales proportionately else: # We find all cash transactions for tranx in firm.accounts: if tranx.type_ == "cash": # And add the sales proceeds proportionately tranx.amount = tranx.amount + (firm_cash / cash_number) # The sales above may have rendered some transactions worthless # So we need to purge all accounts to make sure everything is in order transaction = Transaction() transaction.purge_accounts(environment) # Finally, we remove the goods which weren't sold from firms' accounts # As they are perishable self.remove_goods_firms(environment, time) logging.info(" goods consumed on step: %s", time)