def test_awards():
rdz = Rediz(**REDIZ_TEST_CONFIG)
admin_rdz = AdminRediz(**REDIZ_TEST_CONFIG)
write_key = EXACTABLE_FOX
public_write_key = MicroConventions.shash(write_key)
# Add initial awards
award_dict = {
"bivariate": 500,
"trivariate": 1000,
}
admin_rdz.add_award(write_key=public_write_key, award_dict=award_dict)
assert rdz.get_awards(write_key) == award_dict
# Add another award
award_dict_2 = {
"regular": 250,
}
admin_rdz.add_award(write_key=public_write_key, award_dict=award_dict_2)
award_dict.update(award_dict_2)
assert rdz.get_awards(write_key) == award_dict
# Test deletion
admin_rdz.remove_award(write_key=public_write_key, award_name="bivariate")
admin_rdz.remove_award(write_key=public_write_key, award_name="trivariate")
admin_rdz.remove_award(write_key=public_write_key, award_name="regular")
assert rdz.get_awards(write_key) == {}
print("All passed.")
def test_cdf():
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
cdf = rdz.get_cdf(name='die.json',
delay=310,
values=[-2.5, -1.5, -0.5, 0.5, 1.5, 2.5])
pprint(cdf)
#{'delay': 310, 'values': '-2.5,-1.5,-0.5,0.5,1.5,2.5'}
def test_mixed_log():
rdz = Rediz(**REDIZ_TEST_CONFIG)
names = [None, None, random_name()]
write_keys = [random_key(), None, random_key()]
values = [json.dumps([7.6 for _ in range(1000)]), "cat", json.dumps("dog")]
budgets = [1 for _ in names]
result = rdz._pipelined_set(names=names,
write_keys=write_keys,
values=values,
budgets=budgets)
rdz._delete_implementation(names)
def cdf_bar(name,delay=None):
rdz = Rediz(**REDIZ_CONFIG)
try:
cdf = rdz.get_cdf(name=name,delay=int(delay or rdz.delays[0]))
df = pd.DataFrame({'x': cdf['x'], 'y': cdf['y']})
except:
df = pd.DataFrame({'x': [], 'y': []})
data = [
go.Line(
x=df['x'],
y=df['y']
) ]
graphJSON = json.dumps(data, cls=plotly.utils.PlotlyJSONEncoder)
return graphJSON
def evolve():
global Y
time = np.arange(0, 0.02 * 265600, 1)
orbit = odeint(threebody, Y, time)
x, y, z, a, b, c, dx, dy, dz, da, db, dc = orbit.T
values = [x[-1] / SCALE, y[-1] / SCALE, z[-1] / SCALE]
noise = [0.1 * np.random.randn() for v in values]
noisy_values = [v + n for v, n in zip(values, noise)]
rdz = Rediz(**REDIZ_TEST_CONFIG)
budgets = [10., 10., 10.]
res = rdz.cset(names=NAMES,
write_key=REDIZ_TEST_CONFIG['write_key'],
values=noisy_values,
budgets=budgets)
def do_test_delay_string(rdz):
assert 1 in rdz.DELAYS
assert 5 in rdz.DELAYS
NAME = 'test-delay-c6bd-464c-asad-fe9.json'
rdz._delete_implementation(NAME)
time.sleep(0.1)
WRITE_KEY = BELLEHOOD_BAT
assert Rediz.muid_difficulty(
write_key=WRITE_KEY) > 5, "MUID NOT WORKING ?! "
prctl = rdz.set(name=NAME, value="living in the past", write_key=WRITE_KEY)
time.sleep(3)
prctl = rdz.set(name=NAME,
value="living in the present",
write_key=WRITE_KEY)
time.sleep(3)
assert rdz.admin_promises() > 0
delayed_1_value = rdz.get_delayed(name=NAME, delay=1)
assert delayed_1_value == "living in the present"
delayed_5_value = rdz.get_delayed(name=NAME, delay=5)
assert delayed_5_value == "living in the past"
budgets = rdz.get_budgets()
budget = rdz.get_budget(name=NAME)
# Test market
rdz._delete_implementation(NAME)
def lagged_bar(name):
rdz = Rediz(**REDIZ_CONFIG)
try:
lagged_values = rdz.get_lagged_values(name=name)
lagged_times = rdz.get_lagged_times(name=name)
lagged_dt = [ datetime.datetime.fromtimestamp(t).strftime('%c') for t in lagged_times ]
df = pd.DataFrame({'t': reversed(lagged_dt), 'v': reversed(lagged_values)})
except:
df = pd.DataFrame({'t': [], 'v': []})
data = [
go.Bar(
x=df['t'],
y=df['v']
)
]
graphJSON = json.dumps(data, cls=plotly.utils.PlotlyJSONEncoder)
return graphJSON
def test_delete_simple():
rdz = Rediz(**REDIZ_TEST_CONFIG)
name = rdz.random_name()
write_key = BELLEHOOD_BAT
title = {'name': name, 'write_key': write_key}
assert rdz.set(value="42", **title)
dump(title)
v = rdz.get(name)
assert v == "42"
rdz.delete(**title)
time.sleep(1.1)
assert rdz.get(name) is None
def test_mixed():
rdz = Rediz(**REDIZ_TEST_CONFIG)
# Create two new records ... one rejected due to a poor key
names = [None, None, random_name()]
write_keys = [BELLEHOOD_BAT, TASTEABLE_BEE, 'too-short']
values = [json.dumps(8), "cat", json.dumps("dog")]
budgets = [1, 10, 10000]
execution_log = rdz._pipelined_set(names=names,
write_keys=write_keys,
values=values,
budgets=budgets)
assert len(execution_log["executed"]) == 2, "Expected 2 to be executed"
assert len(execution_log["rejected"]) == 1, "Expected 1 rejection"
assert execution_log["executed"][0]["ttl"] > 25, "Expected ttl>25 seconds"
assert sum([int(t["obscure"] == True)
for t in execution_log["executed"]]) == 2, "Expected 2 obscure"
assert sum([int(t["new"] == True)
for t in execution_log["executed"]]) == 2, "Expected 2 new"
rdz._delete_implementation(names)
def model_loop():
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
HOURS = 26
PREDICTIONS_PER_SECOND = 50
for _ in range(60 * 60 * HOURS * PREDICTIONS_PER_SECOND):
before = time.time()
target, prediction_type = model(rdz)
after = time.time()
print("Prediction type " + prediction_type + " for " + target + " took " + str(after - before) + " seconds.")
wait_time = 1 / PREDICTIONS_PER_SECOND - (after - before)
if wait_time > 0:
time.sleep(wait_time)
def dont_test_donate_remote():
rdz = Rediz(**REDIZ_TEST_CONFIG)
DONATION_PASSWORD = rdz.get_donation_password()
ob = rdz._obscurity
write_key_1 = '861f9f15d9d151b9f9e139532c9dca9d'
write_key_2 = '3ea3788a1ef07a257b8608c7087287f0'
res1 = requests.post('https://api.microprediction.org/donations/' +
write_key_1,
data={
'password': DONATION_PASSWORD,
'donor': 'Test'
})
res2 = requests.post('https://api.microprediction.org/donations/' +
write_key_2,
data={
'password': DONATION_PASSWORD,
'donor': 'Test'
})
assert res1.json()['success']
def test_set_repeatedly():
rdz = Rediz(**REDIZ_TEST_CONFIG)
title = {
"name": "3912eb73-f5e6-4f5e-9674-1a320779b7d9.json",
"write_key": TASTEABLE_BEE
}
assert rdz.set(value="17", **title) is not None
assert rdz.set(value="11", **title) is not None
assert rdz.set(value="14", **title) is not None
assert rdz.set(value="12", **title) is not None
assert rdz.set(value="11", **title) is not None
assert rdz.set(value="10", **title) is not None
assert rdz.get(title["name"]) == "10"
rdz.delete(**title)
def test_run_admin_garbage_collection():
rdz = Rediz(**REDIZ_TEST_CONFIG)
rdz.admin_garbage_collection()
names = rdz._names()
if names:
report = rdz._size(name=names[0], with_report=True)
dump(report)
def test_expire():
rdz = Rediz(**REDIZ_TEST_CONFIG)
name = rdz.random_name()
write_key = BELLEHOOD_BAT
assert rdz.set(value="44", name=name, write_key=write_key)
rdz.client.expire(name=name, time=0)
import time
time.sleep(0.1)
assert rdz.get(name) is None
assert rdz.client.sismember(name=rdz._NAMES, value=name)
rdz._delete_implementation(names=[name])
def do_test_transfer(source_balance, recipient_balance, amount, expected_given,
expected_success):
rdz = Rediz(**REDIZ_TEST_CONFIG)
source = '9e716ad7649a44a2bf1d522ffe7d86c2'
recipient = '5e4d88d46f54009ff2fdee07b62f6a75'
rdz.client.hset(name=rdz._BALANCES, key=recipient, value=recipient_balance)
rdz.client.hset(name=rdz._BALANCES, key=source, value=source_balance)
report = rdz.transfer(source_write_key=source,
recipient_write_key=recipient,
amount=amount,
as_record=True)
assert report['success'] == expected_success
if report['success']:
assert report['given'] == expected_given
assert abs(report['received'] -
report['given'] * rdz._DISCOUNT) < 1e-6, 'discount wrong'
new_source_balance = rdz.get_balance(source)
new_recipient_balance = rdz.get_balance(recipient)
assert abs(new_source_balance -
(source_balance - report['given'])) < 1e-5
assert abs(new_recipient_balance -
(report['received'] + recipient_balance)) < 1e-5
rdz.client.hdel(rdz._BALANCES, source, recipient)
def test_donate():
rdz = Rediz(**REDIZ_TEST_CONFIG)
DONATION_PASSWORD = rdz.get_donation_password()
ob = rdz._obscurity
write_key_1 = '861f9f15d9d151b9f9e139532c9dca9d'
write_key_2 = '3ea3788a1ef07a257b8608c7087287f0'
res1 = rdz.donate(write_key=write_key_1,
password=DONATION_PASSWORD,
donor='me')
rdz.donate(write_key=write_key_2, password=DONATION_PASSWORD, donor='you')
donors = rdz.get_donors()
assert len(list(donors.keys())) > 1
def test_set_integer():
rdz = Rediz(**REDIZ_TEST_CONFIG)
title = {
"name": "3912eb73-f5e6-4f5e-9674-1a320779b7d9.json",
"write_key": BELLEHOOD_BAT
}
rdz.delete(**title) # Previous run
res = rdz._pipelined_set(values=[25],
names=[title["name"]],
write_keys=[title["write_key"]],
budgets=[1])
dump(res)
assert res["executed"][0]["value"] == 25
access = {
"name": "3912eb73-f5e6-4f5e-9674-1a320779b7d9.json",
"write_key": TASTEABLE_BEE,
"value": 17
}
assert rdz.set(**access) is not None
rdz._delete_implementation(access["name"])
time.sleep(0.15)
assert not rdz.exists(access["name"])
from rediz.client import Rediz
from rediz.collider_config_private import REDIZ_COLLIDER_CONFIG
example_name = 'electricity-fueltype-nyiso-wind.json'
if __name__ == '__main__':
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
owner = rdz._authority(name=example_name)
assert rdz.animal_from_key(owner) == 'Offcast Goose'
names = [n for n, _ in rdz.get_budgets().items() if 'electricity' in n]
print(names)
pipe = rdz.client.pipeline()
for name in names:
pipe.hset(name=rdz._ownership_name(), key=name, value=owner)
res = pipe.execute()
print(res)
# Check
for name in names:
print(rdz.animal_from_key(rdz._authority(name)))
from rediz.client import Rediz
from rediz.collider_config_private import REDIZ_COLLIDER_CONFIG, STREAM_CREATORS
# Hand of God used to ensure testing streams don't go broke
if __name__ == '__main__':
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
for WRITE_KEY in STREAM_CREATORS:
balance = rdz.client.hget(name=rdz._BALANCES, key=WRITE_KEY)
if balance is not None and float(balance) < -1000:
print(rdz.client.hset(name=rdz._BALANCES, key=WRITE_KEY, value=0))
print('Reset balance for ' + rdz.animal_from_key(WRITE_KEY))
import time
from rediz.collider_config_private import REDIZ_COLLIDER_CONFIG
from rediz.client import Rediz
if __name__ == '__main__':
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
HOURS = 10
for k in range(60 * 60 * 2 * HOURS):
time.sleep(0.5)
garbage_before = time.time()
rdz.admin_garbage_collection()
garbage_after = time.time()
print("Garbage collection took " +
str(garbage_after - garbage_before) + " seconds.")
from rediz.client import Rediz
from rediz.collider_config_private import REDIZ_COLLIDER_CONFIG
from pprint import pprint
PATTERNS = [
'*lagged*z1~*310*', '*lagged*z1~*910*', '*lagged*z2~*310*',
'*lagged*z2~*910*', '*lagged*z3~*310*', '*lagged*z3~*910*'
]
if __name__ == '__main__':
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
for pattern in PATTERNS:
lagged = rdz.client.keys(pattern=pattern)
if lagged:
rdz.client.delete(*lagged)
print('Deleted lags for ' + pattern)
from rediz.client import Rediz
from rediz.collider_config_private import REDIZ_COLLIDER_CONFIG
import pprint
import matplotlib.pyplot as plt
import numpy as np
if __name__ == '__main__':
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
names = ['z2~cop~dvn~70.json']
for name in names:
current = rdz.get(name=name)
lagged = rdz.get_lagged_values(name=name)
print("Current value is "+str(current))
print("--- Lagged values ---")
pprint.pprint(lagged)
original = np.cumsum([0]+list(0.001*np.array(lagged)))
plt.plot(original)
plt.legend(names)
plt.show()
from rediz.client import Rediz
from rediz.collider_config_private import REDIZ_COLLIDER_CONFIG
import pprint
if __name__ == '__main__':
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
NAMES = ['die.json']
cdfs = dict()
for name in NAMES:
cdfs[name] = rdz.get_cdf(name=name,
delay=rdz.DELAYS[0],
top=3,
min_balance=20)
pprint.pprint(cdfs)
from rediz.client import Rediz
from rediz.collider_config_private import REDIZ_COLLIDER_CONFIG
import pprint
from rediz.collider_config_private import BOOZE_MAMMAL
if __name__ == '__main__':
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
entered_in = list()
for name in ['bart_delays.json','hospital_bike_activity']:
for delay in rdz.DELAYS:
owners = rdz._get_sample_owners(name=name,delay=delay)
animals = [ rdz.animal_from_key(key) for key in owners ]
if any( 'Flathat' in animal for animal in animals):
entered_in.append((name,delay))
pprint.pprint(entered_in)
from rediz.client import Rediz
from rediz.rediz_test_config import REDIZ_TEST_CONFIG
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits import mplot3d
rdz = Rediz(**REDIZ_TEST_CONFIG)
from scipy import stats
import math
def rhocov(rho, dim):
return np.eye(dim) + rho * np.ones([dim, dim]) - rho * np.eye(dim)
def _bin(x, width):
return ''.join(str((x >> i) & 1) for i in range(width - 1, -1, -1))
def doit(rho):
dim = 2
n = 50000
mu = [0 for _ in range(dim)]
cov = rhocov(rho=rho, dim=dim)
samples = np.random.multivariate_normal(mean=mu, cov=cov, size=n)
def sample(rho, dim, n):
mu = [0 for _ in range(dim)]
cov = rhocov(rho=rho, dim=dim)
samples = np.random.multivariate_normal(mean=mu, cov=cov, size=n)
std0 = np.nanstd([sum(s) for s in samples])
from rediz.client import Rediz
import pprint
from rediz.collider_config_private import REDIZ_COLLIDER_CONFIG, WRITE_KEY
if __name__ == '__main__':
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
performance = rdz.get_performance(write_key=WRITE_KEY)
pprint.pprint(performance)
import time
from rediz.collider_config_private import REDIZ_COLLIDER_CONFIG
from rediz.client import Rediz
import pprint
if __name__ == '__main__':
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
HOURS = 10
for k in range(60 * 60 * 2 * HOURS):
before = time.time()
pprint.pprint(rdz.admin_bankruptcy())
after = time.time()
print("Bankruptcy took " + str(after - before) + " seconds.")
time.sleep(0.5)
def test_serial_real():
rdz = Rediz(**REDIZ_TEST_CONFIG)
do_serial(rdz)
def dont_test_serial_fake():
rdz = Rediz()
do_serial(rdz)
from rediz.client import Rediz
from pprint import pprint
import json
from rediz.collider_config_private import REDIZ_COLLIDER_CONFIG, FLASHY_COYOTE
if __name__ == '__main__':
rdz = Rediz(**REDIZ_COLLIDER_CONFIG)
confirms = rdz.get_confirms(write_key=FLASHY_COYOTE)
print(FLASHY_COYOTE)
for c in confirms:
c_data = json.loads(c)
if c_data.get('operation') == 'withdraw':
pprint(c_data)
