Python Transaction.add_transaction方法代码示例

# 需要导入模块: from src.transaction import Transaction [as 别名]
# 或者: from src.transaction.Transaction import add_transaction [as 别名]
 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)

# 需要导入模块: from src.transaction import Transaction [as 别名]
# 或者: from src.transaction.Transaction import add_transaction [as 别名]
 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)

# 需要导入模块: from src.transaction import Transaction [as 别名]
# 或者: from src.transaction.Transaction import add_transaction [as 别名]
    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"))

# 需要导入模块: from src.transaction import Transaction [as 别名]
# 或者: from src.transaction.Transaction import add_transaction [as 别名]
    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)

# 需要导入模块: from src.transaction import Transaction [as 别名]
# 或者: from src.transaction.Transaction import add_transaction [as 别名]
    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)

# 需要导入模块: from src.transaction import Transaction [as 别名]
# 或者: from src.transaction.Transaction import add_transaction [as 别名]
    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)

# 需要导入模块: from src.transaction import Transaction [as 别名]
# 或者: from src.transaction.Transaction import add_transaction [as 别名]
 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)

# 需要导入模块: from src.transaction import Transaction [as 别名]
# 或者: from src.transaction.Transaction import add_transaction [as 别名]
 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)

# 需要导入模块: from src.transaction import Transaction [as 别名]
# 或者: from src.transaction.Transaction import add_transaction [as 别名]
 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)

# 需要导入模块: from src.transaction import Transaction [as 别名]
# 或者: from src.transaction.Transaction import add_transaction [as 别名]
 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)

# 需要导入模块: from src.transaction import Transaction [as 别名]
# 或者: from src.transaction.Transaction import add_transaction [as 别名]
 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)