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