def test_hub_if_else(self): s = Scheduler() random = RandomTable(2, rows=100000, scheduler=s) stirrer = Stirrer( update_column="_1", delete_rows=5, update_rows=5, fixed_step_size=100, scheduler=s, ) stirrer.input[0] = random.output.result switch = Switch(condition=lambda x: False, scheduler=s) switch.input[0] = stirrer.output.result max_ = Max(name="max_" + str(hash(random)), scheduler=s) max_.input[0] = switch.output.result min_ = Min(name="min_" + str(hash(random)), scheduler=s) min_.input[0] = switch.output.result_else hub = Hub(scheduler=s) hub.input.table = min_.output.result hub.input.table = max_.output.result pr = Print(proc=self.terse, scheduler=s) pr.input[0] = hub.output.result aio.run(s.start()) res1 = stirrer.result.min() res2 = hub.result self.compare(res1, res2)
def setUpStep(self, step): self.set_step_info("{} rows".format(step * L)) s = Scheduler() random = RandomTable(10, rows=step * L, scheduler=s) s.start() #return random self.random_table = pd.DataFrame( random.output.table.output_module.table().to_dict())
def test_input(self): s=Scheduler() inp = Input(scheduler=s) pr=Print(scheduler=s) pr.input.df = inp.output.df t=threading.Thread(target=do_line,args=(inp,s)) t.start() s.start() self.assertEqual(len(inp.df()), 10)
def p10s_random_min_max(n): StorageEngine.default = "hdf5" s = Scheduler() random = RandomTable(10, rows=n * L, scheduler=s) min_ = Min(name='min_' + str(hash(random)), scheduler=s) min_.input.table = random.output.table max_ = Max(name='max_' + str(hash(random)), scheduler=s) max_.input.table = random.output.table s.start()
def p10s_random_min_max(self): n = self.current_step StorageEngine.default = "hdf5" s = Scheduler() random = RandomTable(10, rows=n * L, scheduler=s) min_ = Min(mid='min_' + str(hash(random)), scheduler=s) min_.input.table = random.output.table max_ = Max(id='max_' + str(hash(random)), scheduler=s) max_.input.table = random.output.table s.start()
def test_filter(self) -> None: s = Scheduler() random = RandomTable(2, rows=100000, scheduler=s) filter_ = FilterMod(expr="_1 > 0.5", scheduler=s) filter_.input[0] = random.output.result pr = Print(proc=self.terse, scheduler=s) pr.input[0] = filter_.output.result aio.run(s.start()) idx = (filter_.get_input_slot("table").data().eval( "_1>0.5", result_object="index")) self.assertEqual(filter_.table.index, bitmap(idx))
def test_max(self): s=Scheduler() random = RandomTable(10, rows=10000, scheduler=s) max=Max(scheduler=s) max.input.df = random.output.df pr=Print(scheduler=s) pr.input.df = max.output.df s.start() res1 = random.df()[random.columns.difference([random.UPDATE_COLUMN])].max() res2 = last_row(max.df(), remove_update=True) self.assertTrue(np.allclose(res1, res2))
def test_random_table(self): s=Scheduler() module=RandomTable(['a', 'b'], rows=10000, scheduler=s) self.assertEqual(module.df().columns[0],'a') self.assertEqual(module.df().columns[1],'b') self.assertEqual(len(module.df().columns), 3) # add the UPDATE_COLUMN prlen = Every(proc=print_len, constant_time=True, scheduler=s) prlen.input.df = module.output.df s.start() self.assertEqual(len(module.df()), 10000) self.assertFalse(module.df()['a'].isnull().any()) self.assertFalse(module.df()['b'].isnull().any())
def test_var(self): s=Scheduler() random = RandomTable(1, rows=1000, scheduler=s) var=Var(scheduler=s) var.input.df = random.output.df pr=Print(scheduler=s) pr.input.df = var.output.df s.start() res1 = random.df()[1].var() res2 = last_row(var.df(), remove_update=True) #print 'res1:', res1 #print 'res2:', res2 self.assertTrue(np.allclose(res1, res2))
def test_random_table2(self): s=Scheduler() # produces more than 4M rows per second on my laptop module=RandomTable(10, rows=10000000, force_valid_ids=True, scheduler=s) self.assertEqual(len(module.df().columns), 11) # add the UPDATE_COLUMN self.assertEqual(module.df().columns[0],'_1') self.assertEqual(module.df().columns[1],'_2') prlen = Every(proc=print_len, constant_time=True, scheduler=s) prlen.input.df = module.output.df s.start() self.assertEqual(len(module.df()), 10000000) self.assertFalse(module.df()['_1'].isnull().any()) self.assertFalse(module.df()['_2'].isnull().any())
def test_mb_k_means(self): #log_level() s=Scheduler() n_clusters = 3 csv = CSVLoader(get_dataset('cluster:s3'),sep=' ',skipinitialspace=True,header=None,index_col=False,scheduler=s) km = MBKMeans(n_clusters=n_clusters, random_state=42, is_input=False, scheduler=s) km.input.df = csv.output.df pr = Print(scheduler=s) pr.input.df = km.output.df e = Every(scheduler=s) e.input.df = km.output.labels s.start() self.assertEquals(len(csv.df()), len(km.labels()))
def test_idxmax(self): s=Scheduler() random = RandomTable(10, rows=10000,throttle=1000, scheduler=s) idxmax=IdxMax(scheduler=s) idxmax.input.df = random.output.df max=Max(scheduler=s) max.input.df = random.output.df pr=Print(scheduler=s) pr.input.df = idxmax.output.max s.start() max1=last_row(max.df(),remove_update=True) #print max1 max2=last_row(idxmax.max(),remove_update=True) #print max2 self.assertTrue((max1==max2).all())
def test_idxmin(self): s=Scheduler() random = RandomTable(10, rows=10000,throttle=1000, scheduler=s) idxmin=IdxMin(scheduler=s) idxmin.input.df = random.output.df min=Min(scheduler=s) min.input.df = random.output.df pr=Print(scheduler=s) pr.input.df = idxmin.output.min s.start() min1=last_row(min.df(),remove_update=True) #print min1 min2=last_row(idxmin.min(),remove_update=True) #print min2 self.assertTrue((min1==min2).all())
def test_repair_min(self) -> None: """ test_repair_min() min without deletes/updates """ s = Scheduler() random = RandomTable(2, rows=100000, scheduler=s) min_ = ScalarMin(name="min_" + str(hash(random)), scheduler=s) min_.input[0] = random.output.result pr = Print(proc=self.terse, scheduler=s) pr.input[0] = min_.output.result aio.run(s.start()) res1 = random.table.min() res2 = min_.psdict self.compare(res1, res2)
def NOtest_vec_distances(self): s=Scheduler() vec=VECLoader(get_dataset('warlogs'),scheduler=s) dis=PairwiseDistances(metric='cosine',scheduler=s) dis.input.df = vec.output.df dis.input.array = vec.output.array cnt = Every(proc=print_len,constant_time=True,scheduler=s) cnt.input.df = dis.output.dist global times times = 0 s.start() df = vec.df() computed = dis.dist() self.assertEquals(computed.shape[0], len(df)) truth = pairwise_distances(vec.toarray(), metric=dis._metric) self.assertTrue(np.allclose(truth, computed))
def p10s_read_csv(self): s = Scheduler() module = CSVLoader(RandomBytesIO(cols=30, size=self.current_step * GIGA), index_col=False, header=None, scheduler=s) module.start()
def test_repair_min2(self) -> None: """ test_repair_min2() runs with sensitive ids deletion """ s = Scheduler() ScalarMin._reset_calls_counter = 0 # type: ignore random = RandomTable(2, rows=100000, scheduler=s) min_ = ScalarMin(name="min_repair_test2", scheduler=s) stirrer = MyStirrer(watched="min_repair_test2", scheduler=s) stirrer.input[0] = random.output.result min_.input[0] = stirrer.output.result pr = Print(proc=self.terse, scheduler=s) pr.input[0] = min_.output.result aio.run(s.start()) self.assertEqual(ScalarMin._reset_calls_counter, 1) # type: ignore res1 = stirrer.table.min() res2 = min_.psdict self.compare(res1, res2)
def test_filter3(self) -> None: s = Scheduler() random = RandomTable(2, rows=100000, scheduler=s) stirrer = Stirrer(update_column="_1", update_rows=5, fixed_step_size=100, scheduler=s) stirrer.input[0] = random.output.result filter_ = FilterMod(expr="_1 > 0.5", scheduler=s) filter_.input[0] = stirrer.output.result pr = Print(proc=self.terse, scheduler=s) pr.input[0] = filter_.output.result aio.run(s.start()) tbl = filter_.get_input_slot("table").data() idx = tbl.eval("_1>0.5", result_object="index") self.assertEqual(filter_.table.index, bitmap(idx)) df = pd.DataFrame(tbl.to_dict(), index=tbl.index.to_array()) dfe = df.eval("_1>0.5") self.assertEqual(filter_.table.index, bitmap(df.index[dfe]))
def test_stirrer(self) -> None: s = Scheduler() random = RandomTable(2, rows=100000, scheduler=s) stirrer = Stirrer( update_column="_1", delete_rows=5, update_rows=5, fixed_step_size=100, scheduler=s, ) stirrer.input[0] = random.output.result max_ = Max(name="max_" + str(hash(random)), scheduler=s) max_.input[0] = stirrer.output.result pr = Print(proc=self.terse, scheduler=s) pr.input[0] = max_.output.result aio.run(s.start()) res1 = stirrer.table.max() res2 = max_.result self.compare(res1, res2)
def test_csv_distances(self): s=Scheduler() vec=CSVLoader(get_dataset('smallfile'),index_col=False,header=None,scheduler=s) dis=PairwiseDistances(metric='euclidean',scheduler=s) dis.input.df = vec.output.df cnt = Every(proc=print_len,constant_time=True,scheduler=s) cnt.input.df = dis.output.dist global times times = 0 s.start(ten_times) df = vec.df() computed = dis.dist() #self.assertEquals(computed.shape[0], len(df)) del df[CSVLoader.UPDATE_COLUMN] offset=0 size=offset+5000 truth = pairwise_distances(df.iloc[offset:size], metric=dis._metric) dist = computed[offset:size,offset:size] self.assertTrue(np.allclose(truth, dist,atol=1e-7)) # reduce tolerance
def test_repair_max3(self) -> None: """ test_repair_max3() runs with NON-sensitive ids deletion """ s = Scheduler() ScalarMax._reset_calls_counter = 0 # type: ignore random = RandomTable(2, rows=100000, scheduler=s) max_ = ScalarMax(name="max_repair_test3", scheduler=s) stirrer = MyStirrer(watched="max_repair_test3", proc_sensitive=False, scheduler=s) stirrer.input[0] = random.output.result max_.input[0] = stirrer.output.result pr = Print(proc=self.terse, scheduler=s) pr.input[0] = max_.output.result aio.run(s.start()) self.assertEqual(ScalarMax._reset_calls_counter, 0) # type: ignore res1 = stirrer.table.max() res2 = max_.psdict self.compare(res1, res2)
def test_select_delta(self): #log_level() delta = np.array([0, 0.05]) points = [[0.0, 0.0], [1.0, 1.0], [1.0, 0.0]] s=Scheduler() df=pd.DataFrame(points) add_to_row=AddToRow(df, scheduler=s) def tick_proc(s, run_number): if run_number > 100: s.stop() #print add_to_row.df() try: add_to_row.from_input({1: delta}) except Exception as e: print 'Error: %s'%e q=SelectDelta(delta=0.5,scheduler=s) q.input.df = add_to_row.output.df prlen = Every(scheduler=s) prlen.input.df = q.output.df s.start(tick_proc=tick_proc) self.assertEqual(len(q.df()), 3)
def test_repair_max5(self) -> None: """ test_repair_max5() runs with sensitive ids update (critical) """ s = Scheduler() ScalarMax._reset_calls_counter = 0 # type: ignore random = RandomTable(2, rows=100000, scheduler=s) max_ = ScalarMax(name="max_repair_test4", scheduler=s) stirrer = MyStirrer(watched="max_repair_test4", mode="update", value=-9999.0, scheduler=s) stirrer.input[0] = random.output.result max_.input[0] = stirrer.output.result pr = Print(proc=self.terse, scheduler=s) pr.input[0] = max_.output.result aio.run(s.start()) self.assertEqual(ScalarMax._reset_calls_counter, 1) # type: ignore res1 = stirrer.table.max() res2 = max_.psdict self.compare(res1, res2)
def scheduler(self): sched = None if getenv("NOTHREAD"): if not self._output: print('[Using non-threaded scheduler]', end=' ', file=sys.stderr) self._output = True sched = BaseScheduler() else: sched = Scheduler() self._schedulers.append(sched) return sched
def test_resetter(self) -> None: """ test_resetter() """ s = Scheduler() resetter = MyResetter(threshold=30000, scheduler=s) def _func(slot: Slot) -> bool: return slot.data().get("reset") is True score = self._common(0.1, resetter=resetter, resetter_func=_func, scheduler=s) print("resetter 30K=>score", score) self.assertGreater(score, 0.77)
def test_switch_if_then(self): s = Scheduler() random = RandomTable(2, rows=100000, scheduler=s) stirrer = Stirrer( update_column="_1", delete_rows=5, update_rows=5, fixed_step_size=100, scheduler=s, ) stirrer.input[0] = random.output.result switch = Switch(condition=lambda x: True, scheduler=s) switch.input[0] = stirrer.output.result max_ = Max(name="max_" + str(hash(random)), scheduler=s) max_.input[0] = switch.output.result pr_else = Print(proc=self.terse, scheduler=s) pr_else.input[0] = switch.output.result_else pr = Print(proc=self.terse, scheduler=s) pr.input[0] = max_.output.result aio.run(s.start()) res1 = stirrer.result.max() res2 = max_.result self.compare(res1, res2)
def test_filter(self): s = Scheduler() random = RandomTable(2, rows=100000, scheduler=s) filter_ = FilterMod(expr='_1 > 0.5', scheduler=s) filter_.input.table = random.output.table pr = Print(proc=self.terse, scheduler=s) pr.input.df = filter_.output.table s.start() s.join() idx = filter_.get_input_slot('table').data().eval( '_1>0.5', result_object='index') self.assertEqual(filter_._table.selection, bitmap(idx))
def test_scheduler(self): s = Scheduler() csv = CSVLoader(get_dataset('bigfile'), name="csv", index_col=False, header=None, scheduler=s) #smp = Sample(n=10,scheduler=s) #smp.input.df = csv.output.table self.assertIs(s["csv"], csv) csv.scheduler().start() sleep(1) self.assertTrue(csv.scheduler().is_running()) #smp2 = Sample(n=15, scheduler=s) #smp2.input.df = csv.output.df def add_min(): m = Min(scheduler=s) # Of course, sleeping here is a bad idea. this is to illustrate # that add_min will be executed atomically by the scheduler. # using a sleep outside of add_oneshot_tick_proc would lead to an inconsistent # state. #sleep(1) m.input.table = csv.output.table prt = Print(proc=self.terse, scheduler=s) prt.input.df = m.output.table s.on_tick_once(add_min) sleep(1) #self.assertTrue(s._runorder.index(smp.id) > s._runorder.index(csv.id)) #self.assertTrue(s._runorder.index(smp2.id) > s._runorder.index(csv.id)) #self.assertTrue(s._runorder.index(m.id) > s._runorder.index(smp2.id)) s.stop() s.join()
def test_dummy(self): s = Scheduler() random = RandomTable(2, rows=100000, scheduler=s) dummy_ = DummyMod(update_column='_1', delete_rows=5, update_rows=5, fixed_step_size=100, scheduler=s) dummy_.input.table = random.output.table max_ = Max(name='max_' + str(hash(random)), scheduler=s) max_.input.table = dummy_.output.table pr = Print(proc=self.terse, scheduler=s) pr.input.df = max_.output.table s.start() s.join()
def test_dataflow(self): s = Scheduler() with Dataflow(s): csv = CSVLoader(get_dataset('bigfile'), name="csv", index_col=False, header=None) m = Min() m.input.table = csv.output.table prt = Print(proc=self.terse) prt.input.df = m.output.table self.assertIs(s["csv"], csv) csv.scheduler().start() sleep(1) self.assertTrue(csv.scheduler().is_running()) s.stop() s.join()
def p10s_random(self): n = self.current_step StorageEngine.default = "hdf5" s = Scheduler() random = RandomTable(10, rows=n * L, scheduler=s) s.start()
""" Clustering datasets may be found at https://cs.joensuu.fi/sipu/datasets/ """ from progressivis import Scheduler, Every#, log_level from progressivis.cluster import MBKMeans from progressivis.io import CSVLoader from progressivis.stats import Min, Max, Histogram2D from progressivis.vis import Heatmap, ScatterPlot from progressivis.datasets import get_dataset try: s = scheduler except NameError: s = Scheduler() #log_level(package="progressivis.cluster") data = CSVLoader(get_dataset('cluster:s3'),sep=' ',skipinitialspace=True,header=None,index_col=False,scheduler=s) mbkmeans = MBKMeans(columns=[0, 1], n_clusters=15, batch_size=100, scheduler=s) mbkmeans.input.df = data.output.df prn = Every(scheduler=s) prn.input.df = mbkmeans.output.df sp = ScatterPlot(0,1, scheduler=s) sp.move_point = mbkmeans # for input management #sp.create_dependent_modules(mbkmeans,'centroids') # Create modules by hand rather than with the utility. # We show the cluster centroids on the scatterplot and the # data as a heatmap # histogram2d histogram2d = Histogram2D(0, 1, scheduler=s)
def filter_(df): lon = df['dropoff_longitude'] lat = df['dropoff_latitude'] return df[(lon>-74.10)&(lon<-73.7)&(lat>40.60)&(lat<41)] def print_len(x): if x is not None: print(len(x)) #log_level() #package='progressivis.stats.histogram2d') try: s = scheduler except: s = Scheduler() #PREFIX= 'https://storage.googleapis.com/tlc-trip-data/2015/' #SUFFIX= '' PREFIX= '../nyc-taxi/' SUFFIX= '.bz2' URLS = [ PREFIX+'yellow_tripdata_2015-01.csv'+SUFFIX, PREFIX+'yellow_tripdata_2015-02.csv'+SUFFIX, PREFIX+'yellow_tripdata_2015-03.csv'+SUFFIX, PREFIX+'yellow_tripdata_2015-04.csv'+SUFFIX, PREFIX+'yellow_tripdata_2015-05.csv'+SUFFIX, PREFIX+'yellow_tripdata_2015-06.csv'+SUFFIX, ]
from progressivis import Scheduler, Print from progressivis.cluster import MBKMeans from progressivis.stats import RandomTable from progressivis.vis import MCScatterPlot import asyncio as aio try: s = scheduler except: s = Scheduler() table = RandomTable(columns=['a', 'b'], rows=50000, throttle=500, scheduler=s) mbkmeans = MBKMeans(columns=['a', 'b'], n_clusters=8, batch_size=100, is_input=False, scheduler=s) mbkmeans.input.table = table.output.table prn = Print(scheduler=s) prn.input.df = mbkmeans.output.table sp = MCScatterPlot(scheduler=s, classes=[('Scatterplot', 'a', 'b')], approximate=True) sp.create_dependent_modules(mbkmeans, 'table') sp['Scatterplot'].range_query_2d.hist_index_x.params.init_threshold = 1 sp['Scatterplot'].range_query_2d.hist_index_y.params.init_threshold = 1 if __name__ == '__main__': #table.start() aio.run(s.start(coros=[aio.sleep(3600)]))
"Test the Histograms visualization module" from progressivis import Scheduler, Every from progressivis.stats import RandomTable, Min, Max from progressivis.vis import Histograms import numpy as np #log_level() try: s = scheduler print('No scheduler defined, using the standard one') except NameError: s = Scheduler() def main(): "Main function" csvmod = RandomTable(columns=['a', 'b', 'c'], rows=1000000, random=np.random.randn, throttle=1000, scheduler=s) minmod = Min(scheduler=s) minmod.input.table = csvmod.output.table maxmod = Max(scheduler=s) maxmod.input.table = csvmod.output.table histograms = Histograms(scheduler=s) histograms.input.table = csvmod.output.table histograms.input.min = minmod.output.table histograms.input.max = maxmod.output.table
bounds_max = {'pickup_latitude': 41.00, 'pickup_longitude': -73.70} def filter(df): lon = df['pickup_longitude'] lat = df['pickup_latitude'] return df[(lon>-74.10)&(lon<-73.7)&(lat>40.60)&(lat<41)] def print_len(x): if x is not None: print len(x) #log_level() #package='progressivis.stats.histogram2d') try: s = scheduler except: s = Scheduler() #PREFIX= 'https://storage.googleapis.com/tlc-trip-data/2015/' #SUFFIX= '' PREFIX= '../nyc-taxi/' SUFFIX= '.bz2' URLS = [ PREFIX+'yellow_tripdata_2015-01.csv'+SUFFIX, PREFIX+'yellow_tripdata_2015-02.csv'+SUFFIX, PREFIX+'yellow_tripdata_2015-03.csv'+SUFFIX, PREFIX+'yellow_tripdata_2015-04.csv'+SUFFIX, PREFIX+'yellow_tripdata_2015-05.csv'+SUFFIX, PREFIX+'yellow_tripdata_2015-06.csv'+SUFFIX, ]
def scheduler(self, clean: bool = False) -> Scheduler: if self._scheduler is None or clean: self._scheduler = Scheduler() return self._scheduler
def _fun(s: Scheduler, r: int) -> None: if r > 10: s.task_stop()
def test_read_csv(self): s=Scheduler() module=CSVLoader(get_dataset('bigfile'), index_col=False, header=None, scheduler=s) self.assertTrue(module.df() is None) s.start() self.assertEqual(len(module.df()), 1000000)
""" Clustering datasets may be found at https://cs.joensuu.fi/sipu/datasets/ """ from progressivis import Scheduler, Every#, log_level from progressivis.cluster import MBKMeans from progressivis.io import CSVLoader from progressivis.vis import ScatterPlot from progressivis.datasets import get_dataset try: s = scheduler except NameError: s = Scheduler() #log_level(package="progressivis.cluster") data = CSVLoader(get_dataset('cluster:s1'),sep='\\s+',skipinitialspace=True,header=None,index_col=False,scheduler=s) mbkmeans = MBKMeans(columns=['_0', '_1'], n_clusters=15, batch_size=100, is_input=False, scheduler=s) mbkmeans.input.table = data.output.table prn = Every(scheduler=s) prn.input.df = mbkmeans.output.table sp = ScatterPlot('_0','_1', scheduler=s) sp.move_point = mbkmeans # for input management sp.create_dependent_modules(data,'table', sample=None, select=mbkmeans) if __name__ == '__main__': data.start() s.join()
from progressivis import Scheduler, Every #, log_level from progressivis.cluster import MBKMeans, MBKMeansFilter from progressivis.io import CSVLoader from progressivis.vis import MCScatterPlot from progressivis.datasets import get_dataset from progressivis.stats import RandomTable from progressivis.utils.psdict import PsDict import pandas as pd import numpy as np import os.path import tempfile from progressivis.datasets.random import generate_random_multivariate_normal_csv as gen_csv try: s = scheduler except NameError: s = Scheduler() #log_level(package="progressivis.cluster") #dir_name = tempfile.mkdtemp(prefix='progressivis_tmp_') dir_name = os.path.join(tempfile.gettempdir(), 'progressivis_tmp_') os.makedirs(dir_name, exist_ok=True) file_name = os.path.join(dir_name, "foobar.csv") gen_csv(file_name, rows=99999, reset=True) #, header='_0,_1', reset=False) data = CSVLoader(file_name, skipinitialspace=True, header=None, index_col=False, scheduler=s) n_clusters = 3 mbkmeans = MBKMeans(columns=['_0', '_1'], n_clusters=n_clusters,
def p10s_zarr_random(n): StorageEngine.default = "zarr" s = Scheduler() random = RandomTable(10, rows=n * L, scheduler=s) s.start()
def test_scheduler(self) -> None: with self.assertRaises(ProgressiveError): s = Scheduler(0) s = Scheduler() csv = CSVLoader( get_dataset("bigfile"), name="csv", index_col=False, header=None, scheduler=s, ) self.assertIs(s["csv"], csv) sink = Sink(name="sink", scheduler=s) sink.input.inp = csv.output.result # allow csv to start check_running = False async def _is_running() -> None: nonlocal check_running check_running = csv.scheduler().is_running() aio.run_gather(s.start(), _is_running()) self.assertTrue(check_running) def add_min(s: Scheduler, r: int) -> None: with s: m = Min(scheduler=s) m.input.table = csv.output.result prt = Print(proc=self.terse, scheduler=s) prt.input.df = m.output.result s.on_loop(add_min, 10) s.on_loop(self._stop, 20) self.assertIs(s["csv"], csv) json = s.to_json(short=False) self.assertFalse(json["is_running"]) self.assertTrue(json["is_terminated"]) html = s._repr_html_() self.assertTrue(len(html) != 0)
def make_df(n, L): s = Scheduler() random = RandomTable(10, rows=n * L, scheduler=s) s.start() #return random return pd.DataFrame(random.output.table.output_module.table().to_dict())