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)
