Comparing model outputs

qwen2.5-coder:3b

def set_parameters(self):
    self.params = {}
    
    # Set initial parameters
    self.set_initial_params()
    
    self.verusd = NodeRpc(
        verusd_rpc_user=self.params.get("rpc_user", ""),
        verusd_rpc_password=self.params.get("rpc_password", ""),
        verusd_rpc_port=16124,
        verusd_rpc_host="localhost"
    )
    # self.verusdvarrr = ... (commented out for brevity)
    
    self.daemonrpc = {}
    self.config = {
        AVAILABLE: {},
        ENABLED: {
            TRADINGPAIRS: [],
            CURRENCYDICTIONARY: [],
            BASKETDICTIONARY: []
        }
    }
    
    # Load currency and basket dictionaries
    self.load_currency_and_basket_dictionaries()
    
    # TODO: Implement functionalization here when ready

def set_initial_params(self):
    self.params = {
        VTRC_MINIMUM_BALANCE: {VTRC_VRSC: 10, VTRC_DAI: 10, VTRC_TBTC: 0.001, VTRC_ETH: 0.01, VTRC_BVETH: 0.5},
        VTRC_TRADING_SETTINGS: VTRC_TRADING_OPS,
        VTRC_TRADING_PAIRS: MY_TRADING_PAIRS,
        "max_trade_pc": self.params.get("max_trade_pc", 0.2),
        VTRC_THRESHOLD: self.params.get("threshold", 0.004),
        "rebalance_threshold": self.params.get("rebalance_threshold", 0.00025),
        "rebalance_balance_pc_trigger": self.params.get("rebalance_balance_pc_trigger", 0.15),
        "rebalance_pc": self.params.get("rebalance_pc", 0.5)
    }

def load_currency_and_basket_dictionaries(self):
    for daemon in VTRC_DAEMONS:
        print(f">>>{daemon}")
        
        # Initialize currency and basket dictionaries
        self.verusd_currency_dictionary = {currency_id: [] for currency_id in self.daemonrpc[daemon].list_currencies()}
        self.verusd_basket_dictionary = {currency_id: [] for currency_id in self.daemonrpc[daemon].list_currencies()}
        
        # Load currencies and filter fractional tokens
        currencies = list(self.daemonrpc[daemon].list_currencies())
        eth_currencies = [currency for currency in currencies if currency["system"] == "vETH"]
        
        # Populate currency dictionary with ETH currencies
        self.verusd_currency_dictionary.update({
            currency_id: {
                CURRENCYID: currency[CURRENCYDEFINITION][CURRENCYID],
                TICKER: currency[CURRENCYDEFINITION][NAME],
                FULLYQUALIFIEDNAME: currency[CURRENCYDEFINITION][FULLYQUALIFIEDNAME]
            }
            for currency in eth_currencies
        })
        
        # Populate currency dictionary with all currencies
        self.verusd_currency_dictionary.update({
            currency_id: {
                CURRENCYID: currency[CURRENCYDEFINITION][CURRENCYID],
                TICKER: currency[CURRENCYDEFINITION][NAME],
                FULLYQUALIFIEDNAME: currency[CURRENCYDEFINITION][FULLYQUALIFIEDNAME]
            }
            for currency in currencies
        })
        
        # Load basket currencies and calculate reserve currencies
        basket_currencies = filter_fractional_tokens(currencies)
        for basket_currency in basket_currencies:
            b_c_id = basket_currency[CURRENCYDEFINITION][CURRENCYID]
            b_c_fqn = self.by_daemon_currency_dictionary_get_fullyqualifiedname_by_currencyid(daemon, basket_currency[CURRENCYDEFINITION][CURRENCYID])
            
            # Skip currencies with zero supply
            if basket_currency[BESTCURRENCYSTATE][SUPPLY] == 0:
                continue
            
            print(f"{basket_currency[CURRENCYDEFINITION][NAME]}: {basket_currency[CURRENCYDEFINITION][CURRENCYID]}")
            
            reserve_currencies = basketcurrency_reservecurrencies(self.daemonrpc[daemon].get_currency_state(basket_currency[CURRENCYDEFINITION][CURRENCYID]))
            currency_ids = [currency["currencyid"] for currency in reserve_currencies]
            fqns = [self.by_daemon_currency_dictionary_get_fullyqualifiedname_by_currencyid(daemon, currency_id) for currency_id in currency_ids]
            
            # Append basket details to dictionary
            self.verusd_basket_dictionary[daemon].append({
                "via": b_c_id,
                "via_name": b_c_fqn,
                "currencyids": currency_ids,
                "tickers": fqns
            })
        
        print(self.get_nice_print_json(self.verusd_basket_dictionary[daemon], f"{daemon} baskets"))
        
        # Add to available currencies and baskets
        self.config[AVAILABLE][CURRENCYDICTIONARY].update(self.verusd_currency_dictionary)
        self.config[AVAILABLE][BASKETDICTIONARY].update(self.verusd_basket_dictionary)

devstral:24b

def set_parameters(
    self,
    max_trade_pc=0.2,
    threshold=0.004,
    rebalance_threshold=0.00025,
    rebalance_balance_pc_trigger=0.15,
    rebalance_pc=0.5,
    rpc_user="",
    rpc_password=""
):
    """
    Sets up the parameters for trading, including minimum balances, thresholds,
    and RPC configurations.

    Args:
        max_trade_pc (float): Maximum trade percentage.
        threshold (float): Trading threshold.
        rebalance_threshold (float): Rebalancing threshold.
        rebalance_balance_pc_trigger (float): Percentage trigger for rebalancing.
        rebalance_pc (float): Percentage for rebalancing.
        rpc_user (str): RPC username.
        rpc_password (str): RPC password.
    """
    self.initialize_params()
    self.setup_rpc_connections()
    self.configure_trading_settings(max_trade_pc, threshold, rebalance_threshold,
                                    rebalance_balance_pc_trigger, rebalance_pc)
    self.populate_currency_and_basket_dictionaries()

def initialize_params(self):
    """Initialize default parameters."""
    self.params = {
        VTRC_MINIMUM_BALANCE: {VTRC_VRSC: 10, VTRC_DAI: 10, VTRC_TBTC: 0.001, VTRC_ETH: 0.01, VTRC_BVETH: 0.5},
        VTRC_TRADING_SETTINGS: VTRC_TRADING_OPS,
        VTRC_TRADING_PAIRS: MY_TRADING_PAIRS,
        VTRC_TRADING_ADDRESS: MY_TRADING_ADDRESS
    }
    self.basket_sell_ht = {}
    self.basket_buy_ht = {}
    self.config = {
        AVAILABLE: {},
        ENABLED: {TRADINGPAIRS: [], CURRENCYDICTIONARY: [], BASKETDICTIONARY: []}
    }
    # TODO remove the self reference here when functionalizing it
    self.verusd_currency_dictionary = {}
    self.verusd_basket_dictionary = {}

def setup_rpc_connections(self):
    """Set up RPC connections for different daemons."""
    self.verusd = NodeRpc(verusd_rpc_user, verusd_rpc_password, verusd_rpc_port, verusd_rpc_host)
    self.verusdvarrr = NodeRpc(verusdvarrr_rpc_user, verusdvarrr_rpc_password, verusdvarrr_rpc_port, verusdvarrr_rpc_host)
    # self.verusdvdex = NodeRpc(verusdvdex_rpc_user, verusdvdex_rpc_password, verusdvdex_rpc_port, verusdvdex_rpc_host)

    self.daemonrpc = {
        VTRC_VERUSD: self.verusd,
        VTRC_VERUSDVARRR: self.verusdvarrr
        # VTRC_VERUSDVDEX: self.verusdvdex
    }

def configure_trading_settings(self, max_trade_pc, threshold, rebalance_threshold, rebalance_balance_pc_trigger, rebalance_pc):
    """Configure trading settings and related parameters."""
    self.params["max_trade_pc"] = max_trade_pc
    self.params[VTRC_THRESHOLD] = MY_THRESHOLD
    self.params["rebalance_threshold"] = rebalance_threshold
    self.params["rebalance_balance_pc_trigger"] = rebalance_balance_pc_trigger
    self.params["rebalance_pc"] = rebalance_pc

def populate_currency_and_basket_dictionaries(self):
    """Populate currency and basket dictionaries based on daemons."""
    for daemon in VTRC_DAEMONS:
        print(f">>>{daemon}")
        self.initialize_daemon_dictionaries(daemon)
        currencies = self.daemonrpc[daemon].list_currencies()
        self.populate_currency_dictionary(daemon, currencies)
        if daemon == VTRC_VERUSD:
            eth_currencies = self.daemonrpc[daemon].list_currencies({"fromsystem": "vETH"})
            self.add_eth_currencies_to_dictionary(daemon, eth_currencies)

        basket_currencies = filter_fractional_tokens(currencies)
        self.populate_basket_dictionary(daemon, basket_currencies)
        self.config[AVAILABLE][CURRENCYDICTIONARY] = self.verusd_currency_dictionary
        self.config[AVAILABLE][BASKETDICTIONARY] = self.verusd_basket_dictionary

def initialize_daemon_dictionaries(self, daemon):
    """Initialize currency and basket dictionaries for a given daemon."""
    self.verusd_currency_dictionary[daemon] = []
    self.verusd_basket_dictionary[daemon] = []

def populate_currency_dictionary(self, daemon, currencies):
    """Populate the currency dictionary with available currencies."""
    for currency in currencies:
        self.verusd_currency_dictionary[daemon].append({
            CURRENCYID: currency[CURRENCYDEFINITION][CURRENCYID],
            TICKER: currency[CURRENCYDEFINITION][NAME],
            FULLYQUALIFIEDNAME: currency[CURRENCYDEFINITION][FULLYQUALIFIEDNAME]
        })

def add_eth_currencies_to_dictionary(self, daemon, eth_currencies):
    """Add Ethereum currencies to the dictionary."""
    for currency in eth_currencies:
        self.verusd_currency_dictionary[daemon].append({
            CURRENCYID: currency[CURRENCYDEFINITION][CURRENCYID],
            TICKER: currency[CURRENCYDEFINITION][NAME],
            FULLYQUALIFIEDNAME: currency[CURRENCYDEFINITION][FULLYQUALIFIEDNAME]
        })

def populate_basket_dictionary(self, daemon, basket_currencies):
    """Populate the basket dictionary with available fractional tokens."""
    for basket_currency in basket_currencies:
        b_c_id = basket_currency[CURRENCYDEFINITION][CURRENCYID]
        b_c_fqn = self.by_daemon_currency_dictionary_get_fullyqualifiedname_by_currencyid(daemon, basket_currency[CURRENCYDEFINITION][CURRENCYID])
        if basket_currency[BESTCURRENCYSTATE][SUPPLY] == 0:
            continue
        print(f"{basket_currency[CURRENCYDEFINITION][NAME]}: {basket_currency[CURRENCYDEFINITION][CURRENCYID]}")
        reserve_currencies = basketcurrency_reservecurrencies(self.daemonrpc[daemon].get_currency_state(basket_currency[CURRENCYDEFINITION][CURRENCYID]))
        currency_ids = [currency["currencyid"] for currency in reserve_currencies]
        fqns = [self.by_daemon_currency_dictionary_get_fullyqualifiedname_by_currencyid(daemon,currency_id) for currency_id in currency_ids]

        self.verusd_basket_dictionary[daemon].append({
            "via": b_c_id,
            "via_name": b_c_fqn,
            "currencyids": currency_ids,
            "tickers": fqns
        })
        print(self.get_nice_print_json(self.verusd_basket_dictionary[daemon], f"{daemon} baskets"))