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)