def test_multiple_attr_calls(self):
x = 3
y = 5
self.assertEqual([
spells.dict_of(x),
spells.dict_of(y),
], [dict(x=x), dict(y=y)])
with self.assertRaises(ValueError):
print([spells.dict_of(x), spells.dict_of(y)])
def test_multiple_attr_calls(self):
x = 3
y = 5
self.assertEqual([
spells.dict_of(x),
spells.dict_of(y),
], [dict(x=x), dict(y=y)])
self.assertEqual(
[spells.dict_of(x), spells.dict_of(y)],
[dict(x=x), dict(y=y)])
def fully_adapted_adaptive_sampling(y,prop_fun,obs_lik,N,):
T = len(y)
N_eff = np.zeros((T,))
x = np.zeros((T, N)) * 0.0
w_curl = np.zeros((T, N)) * 0.0
w = np.zeros((T, N)) * 0.0
a = np.zeros((T, N), dtype="int")
w[0, ] = 1 / N
w_curl[0, ] = 1 / N
# Init x0
x[0, ] = norm.rvs(size=N, loc=0, scale=1.0)
for t in range(1, T):
# Resample
N_eff[t] = 1/np.sum(w[t-1]**2)
if N_eff[t] < 50:
a[t, ] = np.random.choice(np.arange(N), size=N, p=w[t - 1])
else:
a[t, ] = np.arange(0,100)
# Propagate
x[t, ] = prop_fun(x_prev=x[t - 1, a[t, ]], y_t=y[t,], N=N)
# Weights
# w_t = p(y_i | x_i)
w_curl[t, ] = obs_lik(y_t=y[t, ], x_prev=x[t-1, ], N=N)
w[t, ] = w_curl[t, ] / w_curl[t, ].sum()
loglik = (np.log(w_curl.sum(1)) - np.log(N)).sum()
return dict_of(loglik, x, a, w, w_curl, N_eff)
def bootstrap(
y,
prop_fun,
obs_lik,
N,
):
T = len(y)
x = np.zeros((T, N)) * 0.0
w_curl = np.zeros((T, N)) * 0.0
w = np.zeros((T, N)) * 0.0
a = np.zeros((T, N), dtype="int")
w[0, ] = 1 / N
w_curl[0, ] = 1 / N
# Init x0
x[0, ] = norm.rvs(size=N, loc=0, scale=1.0) # same as prior
for t in range(1, T):
# Resample
a[t, ] = np.random.choice(np.arange(N), size=N, p=w[t - 1])
# Propagate
x[t, ] = prop_fun(x_prev=x[t - 1, a[t, ]])
# Weights
# w_t = p(y_i | x_i)
w_curl[t, ] = obs_lik(y_t=y[t, ], x=x[t, ])
w[t, ] = w_curl[t, ] / w_curl[t, ].sum()
loglik = (np.log(w_curl.sum(1)) - np.log(N)).sum()
return dict_of(loglik, x, a, w, w_curl)
def fully_adapted_systematic_sampling(y,prop_fun, obs_lik, N,):
T = len(y)
x = np.zeros((T, N)) * 0.0
w_curl = np.zeros((T, N)) * 0.0
w = np.zeros((T, N)) * 0.0
a = np.zeros((T, N), dtype="int")
w[0, ] = 1 / N
w_curl[0, ] = 1 / N
# Init x0
x[0, ] = norm.rvs(size=N, loc=0, scale=1.0)
for t in range(1, T):
# Resample
offset = np.random.rand()
idx = np.sort( (np.linspace(0,0.99,100)+offset) % 1 )
cum = w[t-1].cumsum()
for i in range(99):
a[t,i] = (idx[i] < cum).argmax()
# Propagate
x[t, ] = prop_fun(x_prev=x[t - 1, a[t, ]], y_t=y[t,], N=N)
# Weights
# w_t = p(y_i | x_i)
w_curl[t, ] = obs_lik(y_t=y[t, ], x_prev=x[t-1, ], N=N)
w[t, ] = w_curl[t, ] / w_curl[t, ].sum()
loglik = (np.log(w_curl.sum(1)) - np.log(N)).sum()
return dict_of(loglik, x, a, w, w_curl)
def test_dict_of(self):
a = 1
obj = SimpleNamespace(b=2)
self.assertEqual(spells.dict_of(
a, obj.b,
c=3, d=4
), dict(
a=a, b=obj.b,
c=3, d=4))
def test_sorcery():
from sorcery import dict_of
def ret1():
""" """
return 1
arg1 = ret1()
columns = dict_of(arg1)
assert columns["arg1"] == arg1
def payout():
rewards = db.select('rewards', ['account', 'sp'], '1=1', 'account', 9999)
for reward in rewards:
recipient = reward["account"]
balance = float(cycler.hive.get_account(bot)['balance'][:-5])
print('Current balance: ' + str(balance))
amount = math.floor(reward['sp'] * 1000) / 1000
print('Next: ' + str(amount) + ' for ' + reward['account'])
if amount >= 0.001 and balance >= amount:
try:
cycler.hive.transfer(
reward['account'], amount, 'HIVE',
'Thank you for being a part of @curangel!', bot)
print('Sending transfer of ' + str(amount) + ' HIVE to ' +
reward['account'])
except:
logger.warning(
f"missed payment of {amount} to {recipient}: transaction error"
)
notify("payout-tx-error", dict_of(amount, recipient))
else:
while float(cycler.hive.get_account(bot)['balance']
[:-5]) == balance:
print('Waiting for transfer...')
sleep(3)
db.update('rewards', {'sp': reward['sp'] - amount},
{'account': reward['account']})
db.insert('reward_payouts', {
'account': reward['account'],
'amount': amount
})
elif balance < amount:
logger.error(
f"missed payment of {amount} to {recipient}: low balance")
notify("payout-low-balance", dict_of(amount, recipient))
elif amount < 0.001:
logger.info(
f"skipped payment of {amount} to {recipient}: below precision threshold"
)
def sendVote(self,uri,weight,id):
last_vote_time = self._get_account()["last_vote_time"]
try:
self.client.commit.vote(uri, weight, self.account)
except:
time.sleep(3)
self.sendVote(uri,weight,id)
else:
self.db.update('upvotes',{'status':'voted with '+str(weight)+'%','vote_time':datetime.datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')},{'id':id})
while last_vote_time == self._get_account()["last_vote_time"]:
# Block until the vote is reflected on the remote node.
# This prevents double vote attempts.
time.sleep(1)
notify("upvote-execute", dict_of(
uri,
weight,
id
))
def sorcery_return() -> None:
"""
:rtype: None
"""
return sorcery.dict_of(a, b, c)
def test_no_starargs_in_dict_of(self):
args = [1, 2]
with self.assertRaises(TypeError):
spells.dict_of(*args)
def package(*args):
return AttrDict(dict_of(args))
self.ci.calc_fields(self.date)
self.pr[:] = self.ci.pr[:]
self.rf[:] = self.ci.rf[:]
self.sf[:] = self.ci.sf[:]
self.tas[:] = self.ci.tas[:]
self.pet[:] = self.ci.pet[:]
# -----------------------------------------------------------------------------
# Set up and run model
# Make a dictionary of required variables
# - i.e. {'dt': dt, 'start_date': start_date, ...}
setup_dict = dict_of(
# Timestep, simulation period, grid details, fixed input arrays
dt, start_date, end_date, nx, ny, dx, mask, elev, flen, cell_order,
# Parameters
icf, lpf, fc, ttm, cfmax, cfr, whc, beta, perc, cflux, k, alpha, k1, tau,
ssm, ssc, ssa, sshdm,
)
m = Model(**setup_dict)
m.run_model()
output_path = 'Z:/DP/Work/HBV/Tests/out_y1.csv'
m.df_cat.to_csv(output_path)
# =============================================================================
# Miscellaneous
# -----------------------------------------------------------------------------
# Examples of parameter bounds
def sorcery_return():
""" """
return sorcery.dict_of(a, b, c)
