How to use the flavio.physics.running.running function in flavio

self.prefactor = prefactor(None, self.par, B, V)
        self.prefactor_conjugate = prefactor(None, self.par_conjugate, B, V)
        self.scale = config['renormalization scale']['bvll']
        self.label = meson_quark[(B,V)] + lep + lep # e.g. bsmumu, bdtautau
        self.wctot_dict = wctot_dict(wc_obj, self.label, self.scale, par)
        self._ff = {}
        self._wceff = {}
        self._wceff_bar = {}
        self._ha = {}
        self._ha_bar = {}
        self._j = {}
        self._j_bar = {}
        self.ml = par['m_'+lep]
        self.mB = par['m_'+B]
        self.mV = par['m_'+V]
        self.mb = running.get_mb(par, self.scale)

def run_wc_df2(par, c_in, scale_in, scale_out):
    return running.get_wilson(par, c_in, df2_rge_derivative, scale_in, scale_out)

def _br_Dlnu(wc_obj, par, P, lep, nu):
    # CKM element
    if P=='D+':
        Vij = flavio.physics.ckm.get_ckm(par)[1,0].conj() # Vcd*
        qiqj = 'dc'
    elif P=='Ds':
        Vij = flavio.physics.ckm.get_ckm(par)[1,1].conj() # Vcs*
        qiqj = 'sc'
    scale = flavio.config['renormalization scale']['dll']
    # Wilson coefficients
    wc = wc_obj.get_wc(qiqj + lep + 'nu' + nu, scale, par, nf_out=4)
    # add SM contribution to Wilson coefficient
    if lep == nu:
        wc['CVL_'+qiqj+lep+'nu' + nu] += flavio.physics.bdecays.wilsoncoefficients.get_CVLSM(par, scale, nf=4)
    mb = flavio.physics.running.running.get_mb(par, scale)
    mc = flavio.physics.running.running.get_mc(par, scale)
    return br_plnu_general(wc, par, Vij, P, qiqj, lep, nu, mb, mc, delta=0)

def get_hqet_parameters(par, scale):
    p = {}
    alphas = running.get_alpha(par, scale, nf_out=5)['alpha_s']
    p['ash'] = alphas / pi
    p['mb'] = running.get_mb_pole(par)
    p['mc'] = p['mb'] - 3.4
    p['mb1S'] = running.get_mb_1S(par)
    mBbar = (par['m_B0'] + 3 * par['m_B*0']) / 4
    # eq. (25); note the comment about the renormalon cancellation thereafter
    p['Lambdabar'] = mBbar - p['mb1S'] + par['lambda_1'] / (2 * p['mb1S'])
    p['epsc'] = p['Lambdabar'] / (2 * p['mc'])
    p['epsb'] = p['Lambdabar'] / (2 * p['mb'])
    p['zc'] = p['mc'] / p['mb']
    return p

def get_input(par, B, V, scale):
    mB = par['m_'+B]
    mb = running.get_mb_pole(par)
    mc = running.get_mc_pole(par)
    alpha_s = running.get_alpha(par, scale)['alpha_s']
    q = meson_spectator[(B,V)] # spectator quark flavour
    qiqj = meson_quark[(B,V)]
    eq = quark_charge[q] # charge of the spectator quark
    ed = -1/3.
    eu = 2/3.
    xi_t = ckm.xi('t', qiqj)(par)
    xi_u = ckm.xi('u', qiqj)(par)
    eps_u = xi_u/xi_t
    return mB, mb, mc, alpha_s, q, eq, ed, eu, eps_u, qiqj

def isgur_wise(process, q2, ff, par, scale):
    pd = flavio.physics.bdecays.formfactors.b_v.cln.process_dict[process]
    mB = par['m_'+pd['B']]
    mV = par['m_'+pd['V']]
    mb = flavio.physics.running.running.get_mb_pole(par)
    if pd['q'] == 'b->c':
        mq = flavio.physics.running.running.get_mc_pole(par)
    else:
        mq = 0 # neglect m_u,d,s
    # power corrections
    a_T1  = par[process + ' IW a_T1']
    a_T2  = par[process + ' IW a_T2']
    a_T23 = par[process + ' IW a_T23']
    # cf. eq. (11) of arXiv:1503.05534
    ff['T1'] = (mb + mq)/(mB + mV)*ff['V']  * ( 1 + a_T1 )
    ff['T2'] = (mb - mq)/(mB - mV)*ff['A1'] * ( 1 + a_T2 )
    if q2 == 0:
        ff['T23'] = (4*ff['A12']*(mb - mq)*(mB**2 + mV**2))/((mB - mV)**2*(mB + mV))
    else:
        ff['T23'] = ((mb - mq)* (
                ((mB - mV)**2 - q2)* ((mB + mV)**2 - q2)*ff['A0']
                + 8*mB*mV* (-mB**2 + mV**2)* ff['A12']
                ))/ (4.*mB*(mV - mB)*mV*q2) * ( 1 + a_T23 )

def prefactor(q2, par, B, V):
    GF = par['GF']
    scale = config['renormalization scale']['bvll']
    alphaem = running.get_alpha(par, scale)['alpha_e']
    di_dj = meson_quark[(B,V)]
    xi_t = ckm.xi('t',di_dj)(par)
    return 4*GF/sqrt(2)*xi_t*alphaem/(4*pi)