def test_unpickle_errors_intenum_missing_value():
class Fruit2(enum.IntEnum):
APPLE = 1
s = quickle.dumps(Fruit.ORANGE, registry=[Fruit])
with pytest.raises(ValueError, match="Fruit2"):
quickle.loads(s, registry=[Fruit2])
def test_unpickle_errors_enum_missing_attribute():
class PyObjects2(enum.Enum):
LIST = []
s = quickle.dumps(PyObjects.OBJECT, registry=[PyObjects])
with pytest.raises(AttributeError, match="OBJECT"):
quickle.loads(s, registry=[PyObjects2])
def test_dumps_and_loads_unpickleable_types(value):
with pytest.raises(TypeError):
quickle.dumps(value)
o = pickle.dumps(value, protocol=5)
with pytest.raises(quickle.DecodingError):
quickle.loads(o)
def test_unpickle_errors_obj_in_registry_is_not_struct_type():
class Foo(object):
pass
x = MyStruct(1, 2)
s = quickle.dumps(x, registry=[MyStruct])
with pytest.raises(TypeError, match="Value for typecode"):
quickle.loads(s, registry=[Foo])
def test_loads_timedelta_out_of_range(positive):
s = quickle.dumps(datetime.timedelta(days=1234))
days = TIMEDELTA_MAX_DAYS + 1
if not positive:
days = -days
key = (1234).to_bytes(4, "little", signed=True)
bad = s.replace(key, days.to_bytes(4, "little", signed=True))
with pytest.raises(OverflowError):
quickle.loads(bad)
def test_loads_buffers_errors():
obj = quickle.PickleBuffer(b"hello")
res, _ = quickle.dumps(obj, collect_buffers=True)
with pytest.raises(TypeError):
quickle.loads(res, buffers=object())
with pytest.raises(quickle.DecodingError):
quickle.loads(res, buffers=[])
def test_zoneinfo_not_found():
try:
import zoneinfo # noqa
pytest.skip("zoneinfo successfully imported")
except ImportError:
pass
with pytest.raises(quickle.DecodingError, match="zoneinfo"):
quickle.loads(b"\x8c\x0fAmerica/Chicago\xc0.")
def test_pickle_memoize_function_settings(memoize):
obj = [[1], [2]]
res = quickle.dumps(obj, memoize=memoize)
assert opcode_in_pickle(pickle.MEMOIZE, res) == memoize
obj2 = quickle.loads(res)
assert obj == obj2
obj = [[]] * 2
res = quickle.dumps(obj, memoize=memoize)
assert opcode_in_pickle(pickle.MEMOIZE, res) == memoize
obj2 = quickle.loads(res)
assert obj == obj2
assert (obj2[0] is not obj2[1]) == (not memoize)
def test_pickle_enum_codes(code):
p_registry = {Fruit: code}
u_registry = {code: Fruit}
s = quickle.dumps(Fruit.APPLE, registry=p_registry)
x2 = quickle.loads(s, registry=u_registry)
assert x2 == Fruit.APPLE
def check(obj, sol=None):
if sol is None:
sol = obj
quick_res = quickle.dumps(obj)
obj2 = quickle.loads(quick_res)
assert obj2 == sol
assert type(obj2) is type(sol)
obj3 = pickle.loads(quick_res)
assert obj3 == sol
assert type(obj3) is type(sol)
pickle_res = pickle.dumps(obj, protocol=5)
obj4 = quickle.loads(pickle_res)
assert obj4 == sol
assert type(obj4) is type(sol)
def test_struct_registry_mismatch_extra_args_are_ignored():
"""Unpickling a struct with an older version that has fewer parameters
works (the extra args are ignored)."""
x = MyStruct2(1, 2)
s = quickle.dumps(x, registry=[MyStruct2])
x2 = quickle.loads(s, registry=[MyStruct])
assert x2.x == 1
assert x2.y == 2
def test_pickle_struct_recursive():
x = MyStruct(1, None)
x.y = x
s = quickle.dumps(x, registry=[MyStruct])
x2 = quickle.loads(s, registry=[MyStruct])
assert x2.x == 1
assert x2.y is x2
assert type(x) is MyStruct
def get_spots_available_obj(tournament):
roster_data = tournament.roster
if roster_data != None:
roster = quickle.loads(roster_data)
if roster != None:
available = tournament.spots_reserved - len(roster)
if available < 0:
available = 0
return available
def test_pickle_struct_codes(code):
x = MyStruct(1, 2)
p_registry = {MyStruct: code}
u_registry = {code: MyStruct}
s = quickle.dumps(x, registry=p_registry)
x2 = quickle.loads(s, registry=u_registry)
assert x2 == x
def test_struct_registry_mismatch_fewer_args_default_parameters_respected():
"""Unpickling a struct with a newer version that has additional default
parameters at the end works (the defaults are used)."""
x = MyStruct(1, 2)
s = quickle.dumps(x, registry=[MyStruct])
x2 = quickle.loads(s, registry=[MyStruct2])
assert isinstance(x2, MyStruct2)
assert x2.x == x.x
assert x2.y == x.y
assert x2.z == []
assert x2.z2 == 3
def remove_user_from_roster_obj(tournament, user_id):
roster_data = tournament.roster
if roster_data != None:
user_id = is_valid_uuid(user_id)
if user_id != None:
user_id = str(user_id)
roster = quickle.loads(roster_data)
new_roster = []
for user in roster:
if user != user_id:
new_roster.append(user)
tournament.roster = quickle.dumps(new_roster)
def test_pickler_collect_buffers_false(cls):
data = cls(b"hello")
pbuf = quickle.PickleBuffer(data)
enc = quickle.Encoder(collect_buffers=False)
assert not enc.collect_buffers
with pytest.raises(AttributeError):
enc.collect_buffers = True
# By default buffers are serialized in-band
res = enc.dumps(pbuf)
assert quickle.loads(res) == data
# Override None uses default
res = enc.dumps(pbuf, collect_buffers=None)
assert quickle.loads(res) == data
# Override False is the same as default
res = enc.dumps(pbuf, collect_buffers=False)
assert quickle.loads(res) == data
# Override True works
res, buffers = enc.dumps(pbuf, collect_buffers=True)
assert buffers == [pbuf]
assert quickle.loads(res, buffers=buffers) is pbuf
# If no buffers present, output is None
res, buffers = enc.dumps(data, collect_buffers=True)
assert buffers is None
assert quickle.loads(res, buffers=buffers) == data
# Override doesn't persist
res = enc.dumps(pbuf)
assert quickle.loads(res) == data
def test_struct_gc_set_on_unpickle():
"""Unpickling doesn't go through the struct constructor"""
class Test(quickle.Struct):
x: object
y: object
ts = [Test(1, 2), Test(3, "hello"), Test([], ()), Test((), ())]
a, b, c, d = quickle.loads(quickle.dumps(ts, registry=[Test]), registry=[Test])
assert not gc.is_tracked(a)
assert not gc.is_tracked(b)
assert gc.is_tracked(c)
assert not gc.is_tracked(d)
def test_quickle_pickle_collect_buffers_false_compatibility(cls):
data = cls(b"hello")
pbuf = quickle.PickleBuffer(data)
# quickle -> pickle
quick_res = quickle.dumps(pbuf)
obj = pickle.loads(quick_res)
assert obj == data
# pickle -> quickle
pickle_res = pickle.dumps(pbuf, protocol=5)
obj = quickle.loads(pickle_res)
assert obj == data
def basic_oil_pattern():
oil_pattern = Oil_Pattern.objects.all()[9]
print(oil_pattern.pattern_name)
if oil_pattern:
pattern_cache = quickle.loads(oil_pattern.pattern_cache)
else:
pattern_cache = []
return {
'oil': oil_pattern,
'oil_colors': get_oil_colors(),
'pattern_cache': pattern_cache
}
def add_user_to_roster_obj(tournament, user_id):
roster_data = tournament.roster
if roster_data != None:
user_id = is_valid_uuid(user_id)
if user_id != None:
user_id = str(user_id)
roster = quickle.loads(roster_data)
roster_length = len(roster)
if roster_length < tournament.spots_reserved:
exists = False
for user in roster:
if user == user_id:
exists = True
if not exists:
roster.append(user_id)
tournament.roster = quickle.dumps(roster)
def test_quickle_pickle_collect_buffers_true_compatibility(cls):
data = cls(b"hello")
pbuf = quickle.PickleBuffer(data)
# quickle -> pickle
quick_res, quick_buffers = quickle.dumps(pbuf, collect_buffers=True)
obj = pickle.loads(quick_res, buffers=quick_buffers)
assert obj is pbuf
# pickle -> quickle
pickle_buffers = []
pickle_res = pickle.dumps(pbuf,
buffer_callback=pickle_buffers.append,
protocol=5)
obj = quickle.loads(pickle_res, buffers=pickle_buffers)
assert obj is pbuf
def get_list_of_all_patterns():
oil_patterns = Oil_Pattern.objects.all()
temp = {}
for oil_pattern in oil_patterns:
pattern_cache = oil_pattern.pattern_cache
if pattern_cache is not None:
pattern_cache = quickle.loads(pattern_cache)
data = []
data.append(oil_pattern.pattern_name)
data.append(oil_pattern.pattern_db_id)
data.append(pattern_cache)
data.append(oil_pattern.pattern_forward)
data.append(oil_pattern.pattern_backward)
data.append(oil_pattern.pattern_length)
data.append(oil_pattern.pattern_volume)
data.append(oil_pattern.pattern_ratio)
temp[str(oil_pattern.pattern_id)] = data
return temp
def test_pickle_struct(registry_type, use_functions):
if registry_type == "list":
p_registry = u_registry = [MyStruct]
else:
p_registry = {MyStruct: 0}
u_registry = {0: MyStruct}
x = MyStruct(1, 2)
if use_functions:
s = quickle.dumps(x, registry=p_registry)
x2 = quickle.loads(s, registry=u_registry)
else:
enc = quickle.Encoder(registry=p_registry)
dec = quickle.Decoder(registry=u_registry)
s = enc.dumps(x)
x2 = dec.loads(s)
assert x == x2
def test_pickler_collect_buffers_true(cls):
data = cls(b"hello")
pbuf = quickle.PickleBuffer(data)
enc = quickle.Encoder(collect_buffers=True)
assert enc.collect_buffers
with pytest.raises(AttributeError):
enc.collect_buffers = False
# No buffers present returns None
res, buffers = enc.dumps(data)
assert buffers is None
assert quickle.loads(res) == data
# Buffers are collected and returned
res, buffers = enc.dumps(pbuf)
assert buffers == [pbuf]
assert quickle.loads(res, buffers=buffers) is pbuf
# Override None uses default
res, buffers = enc.dumps(pbuf, collect_buffers=None)
assert buffers == [pbuf]
assert quickle.loads(res, buffers=buffers) is pbuf
# Override True is same as default
res, buffers = enc.dumps(pbuf, collect_buffers=True)
assert buffers == [pbuf]
assert quickle.loads(res, buffers=buffers) is pbuf
# Override False disables buffer collecting
res = enc.dumps(pbuf, collect_buffers=False)
assert quickle.loads(res) == data
# Override doesn't persist
res, buffers = enc.dumps(pbuf)
assert buffers == [pbuf]
assert quickle.loads(res, buffers=buffers) is pbuf
def raw_scores(self):
if self.data_raw_scores:
return quickle.loads(self.data_raw_scores)
return []
def scoring_data(self):
if self.data_scoring:
return quickle.loads(self.data_scoring)
return []
def deserialize_tournaments_list(data):
return quickle.loads(data)
def test_zoneinfo(zoneinfo_parts, ind):
x = zoneinfo_parts[ind]
s = quickle.dumps(x)
x2 = quickle.loads(s)
assert x == x2
def test_timezone(offset):
x = datetime.timezone(offset)
s = quickle.dumps(x)
x2 = quickle.loads(s)
assert x == x2
