def test_str_serialization(self, db: LevelDB) -> None:
if db.read_only:
return
a = "just testing some conversions... :)"
db["key"] = a
assert a == db["key"]
db["key"] = b"value_bytes1"
assert db["key"] == b"value_bytes1"
db["key"] = encode(a)
assert db["key"] == encode(a)
del db["key"]
assert len(db) == 0
def test_json_serialization(self, db: LevelDB) -> None:
if db.read_only:
return
a = {"key1": 10.5, "key2": [1, 2, {"key3": -1}]}
db["key"] = a
assert db["key"] == a
assert a == db["key"]
db["key"] = str.encode(rapidjson.dumps(a), encoding="utf-8")
assert db["key"] == str.encode(rapidjson.dumps(a), encoding="utf-8")
db["key"] = encode(a)
assert db["key"] == encode(a)
del db["key"]
assert len(db) == 0
def test_int_encoding_decoding(self) -> None:
a = 42
a_encoded = encode(a)
assert a_encoded[:1] == b"i"
assert base64.b64encode(a_encoded) == b"aQAAAAAAAAAAAAAAAAAAACo="
b = decode(a_encoded)
assert b == 42
assert a == b
def test_json_encoding_decoding(self) -> None:
a = {"test1": 3.0, "test2": {"inner": 0}}
a_encoded = encode(a)
assert a_encoded[:1] == b"j"
assert a_encoded == b'j{"test1":3.0,"test2":{"inner":0}}'
b = decode(a_encoded)
assert b == {"test1": 3.0, "test2": {"inner": 0}}
assert a == b
def test_str_encoding_decoding(self) -> None:
a = "test in progress... :)"
a_encoded = encode(a)
assert a_encoded[:1] == b"s"
assert a_encoded == b"stest in progress... :)"
b = decode(a_encoded)
assert b == "test in progress... :)"
assert a == b
def test_int_serialization(self, db: LevelDB) -> None:
if db.read_only:
return
for a in [42, -100000000000000000000000000, int(1e10)]:
db["key"] = a
assert db["key"] == a
db["key"] = int.to_bytes(a,
length=16,
byteorder="big",
signed=True)
assert db["key"] == int.to_bytes(a,
length=16,
byteorder="big",
signed=True)
db["key"] = encode(a)
assert db["key"] == encode(a)
del db["key"]
assert len(db) == 0
def test_numpy_encoding_decoding(self) -> None:
a = np.array([[0, 1.13], [1, 42]])
a_encoded = encode(a)
assert a_encoded[:1] == b"n"
assert (base64.b64encode(a_encoded) ==
b"bpNOVU1QWQEAdgB7J2Rlc2NyJzogJzxmOCcsICdmb3J0cmFuX29yZGVyJz"
b"ogRmFsc2UsICdzaGFwZSc6ICgyLCAyKSwgfSAgICAgICAgICAgICAgICAgI"
b"CAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKAAAAA"
b"AAAAAAUrkfhehTyPwAAAAAAAPA/AAAAAAAARUA=")
b = decode(a_encoded)
assert repr(b) == repr(a)
assert np.array_equal(a, b)
def __setitem__(self, key: Union[str, Iterable[str]], value: Any) -> Response:
*prefixes, key = normalize_strings(lambda x: x, key)
if key is Ellipsis:
raise TypeError(f"str prefix or key expected, got {type(key).__name__}")
res = requests.post(
url=self.server_address + "/setitem",
data=encode(value),
headers={"Content-Type": "application/octet-stream"},
params={"dbpath": self.db_path, "key": key, "prefixes": prefixes},
)
return res
def test_numpy_serialization(self, db: LevelDB) -> None:
if db.read_only:
return
a = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], dtype=np.float16)
db["key"] = a
assert repr(db["key"]) == repr(a)
assert np.array_equal(a, db["key"])
db["key"] = Serializer.ndarray_tobytes(a)
assert db["key"] == Serializer.ndarray_tobytes(a)
db["key"] = encode(a)
assert repr(decode(db["key"])) == repr(a)
assert np.array_equal(a, decode(db["key"]))
del db["key"]
assert len(db) == 0
def dblen() -> str:
db = _parse_and_get_prefixed_db()
starting_by = request.args.get("starting_by")
starting_by = b"".join(
serializer.normalize_strings(DecodeType.STR.pure_encode_fun, starting_by)
if starting_by is not None
else ()
)
out = serializer.encode(
sum(
1
for _ in db.iterator(
include_key=True, include_value=False, prefix=starting_by
)
)
)
return Response(out, content_type="application/octet-stream")
