class RawStorage(BaseStorage):
""" Saves metrics as is """
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._metrics = Map()
self._storage_class = list
def __iter__(self) -> AsyncIterable[Metric]:
current_time = int(time.time())
for name, metrics in self._metrics.items(): # type: Counter
returning = list()
for ts, value in metrics:
if ts >= current_time:
returning.append((ts, value))
continue
yield Metric(name=name, timestamp=ts, value=value)
metrics.clear()
if not returning:
continue
metrics.extend(returning)
log.info(
"%d metric(s) of %r weren't sent yet because they're "
"newer than the current timestamp %d", len(returning), name,
current_time)
def add(self, metric: Metric, operation=None):
self._get_metric(metric.name).append((metric.timestamp, metric.value))
def test_map_gc_2(self):
A = HashKey(100, 'A')
h = Map()
h = h.set(A, 'a')
h = h.set(A, h)
ref = weakref.ref(h)
hi = h.items()
next(hi)
del h, hi
gc.collect()
gc.collect()
gc.collect()
self.assertIsNone(ref())
def test_map_items_2(self):
A = HashKey(100, 'A')
B = HashKey(101, 'B')
C = HashKey(100100, 'C')
D = HashKey(100100, 'D')
E = HashKey(100100, 'E')
F = HashKey(110, 'F')
h = Map()
h = h.set(A, 'a')
h = h.set(B, 'b')
h = h.set(C, 'c')
h = h.set(D, 'd')
h = h.set(E, 'e')
h = h.set(F, 'f')
it = h.items()
self.assertEqual(set(list(it)), {(A, 'a'), (B, 'b'), (C, 'c'),
(D, 'd'), (E, 'e'), (F, 'f')})
class TotalStorage(BaseStorage):
""" Adds up values of the same metrics with the same timestamps """
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self._metrics = Map()
self._storage_class = Counter
def __iter__(self) -> AsyncIterable[Metric]:
current_time = int(time.time())
for name, metrics in self._metrics.items(): # type: Counter
returning = list()
while metrics:
ts, value = metrics.popitem()
if ts >= current_time:
returning.append((ts, value))
continue
yield Metric(name=name, timestamp=ts, value=value)
for ts, value in returning:
metrics[ts] += value
"9": "blue",
"a": "green",
"b": "aqua",
"c": "red",
"d": "light_purple",
"e": "yellow",
"f": "white",
"k": "obfuscated",
"l": "bold",
"m": "strikethrough",
"n": "underlined",
"o": "italic",
"r": "reset",
})
FORMAT_BY_NAME = Map({v: k for k, v in FORMAT_BY_CODE.items()})
TERMINAL_CODES = Map({
"0": "\x1b[30m",
"1": "\x1b[34m",
"2": "\x1b[32m",
"3": "\x1b[36m",
"4": "\x1b[31m",
"5": "\x1b[35m",
"6": "\x1b[33m",
"7": "\x1b[37m",
"8": "\x1b[90m",
"9": "\x1b[94m",
"a": "\x1b[92m",
"b": "\x1b[96m",
"c": "\x1b[91m",
def test_map_items_3(self):
h = Map()
self.assertEqual(len(h.items()), 0)
self.assertEqual(list(h.items()), [])
def test_map_stress(self):
COLLECTION_SIZE = 7000
TEST_ITERS_EVERY = 647
CRASH_HASH_EVERY = 97
CRASH_EQ_EVERY = 11
RUN_XTIMES = 3
for _ in range(RUN_XTIMES):
h = Map()
d = dict()
for i in range(COLLECTION_SIZE):
key = KeyStr(i)
if not (i % CRASH_HASH_EVERY):
with HaskKeyCrasher(error_on_hash=True):
with self.assertRaises(HashingError):
h.set(key, i)
h = h.set(key, i)
if not (i % CRASH_EQ_EVERY):
with HaskKeyCrasher(error_on_eq=True):
with self.assertRaises(EqError):
h.get(KeyStr(i)) # really trigger __eq__
d[key] = i
self.assertEqual(len(d), len(h))
if not (i % TEST_ITERS_EVERY):
self.assertEqual(set(h.items()), set(d.items()))
self.assertEqual(len(h.items()), len(d.items()))
self.assertEqual(len(h), COLLECTION_SIZE)
for key in range(COLLECTION_SIZE):
self.assertEqual(h.get(KeyStr(key), 'not found'), key)
keys_to_delete = list(range(COLLECTION_SIZE))
random.shuffle(keys_to_delete)
for iter_i, i in enumerate(keys_to_delete):
key = KeyStr(i)
if not (iter_i % CRASH_HASH_EVERY):
with HaskKeyCrasher(error_on_hash=True):
with self.assertRaises(HashingError):
h.delete(key)
if not (iter_i % CRASH_EQ_EVERY):
with HaskKeyCrasher(error_on_eq=True):
with self.assertRaises(EqError):
h.delete(KeyStr(i))
h = h.delete(key)
self.assertEqual(h.get(key, 'not found'), 'not found')
del d[key]
self.assertEqual(len(d), len(h))
if iter_i == COLLECTION_SIZE // 2:
hm = h
dm = d.copy()
if not (iter_i % TEST_ITERS_EVERY):
self.assertEqual(set(h.keys()), set(d.keys()))
self.assertEqual(len(h.keys()), len(d.keys()))
self.assertEqual(len(d), 0)
self.assertEqual(len(h), 0)
# ============
for key in dm:
self.assertEqual(hm.get(str(key)), dm[key])
self.assertEqual(len(dm), len(hm))
for i, key in enumerate(keys_to_delete):
hm = hm.delete(str(key))
self.assertEqual(hm.get(str(key), 'not found'), 'not found')
dm.pop(str(key), None)
self.assertEqual(len(d), len(h))
if not (i % TEST_ITERS_EVERY):
self.assertEqual(set(h.values()), set(d.values()))
self.assertEqual(len(h.values()), len(d.values()))
self.assertEqual(len(d), 0)
self.assertEqual(len(h), 0)
self.assertEqual(list(h.items()), [])
