This is an automated email from the ASF dual-hosted git repository.
chaokunyang pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/fory.git
The following commit(s) were added to refs/heads/main by this push:
new 15d470467 feat(python): refine python api and readme (#2673)
15d470467 is described below
commit 15d470467832aea703a2598987a3793228d6c724
Author: Shawn Yang <[email protected]>
AuthorDate: Sun Sep 28 13:11:29 2025 +0800
feat(python): refine python api and readme (#2673)
## Why?
Make API more consise and shorter to ease the usage.
## What does this PR do?
Refine python API:
```python
fory = Fory(xlang=False, ref=True)
obj = {"a": 1, "b": 2}
data = fory.dumps(obj)
new_obj = fory.loads(data)
assert obj == new_obj
```
## Related issues
<!--
Is there any related issue? If this PR closes them you say say
fix/closes:
- #xxxx0
- #xxxx1
- Fixes #xxxx2
-->
## Does this PR introduce any user-facing change?
<!--
If any user-facing interface changes, please [open an
issue](https://github.com/apache/fory/issues/new/choose) describing the
need to do so and update the document if necessary.
Delete section if not applicable.
-->
- [ ] Does this PR introduce any public API change?
- [ ] Does this PR introduce any binary protocol compatibility change?
## Benchmark
<!--
When the PR has an impact on performance (if you don't know whether the
PR will have an impact on performance, you can submit the PR first, and
if it will have impact on performance, the code reviewer will explain
it), be sure to attach a benchmark data here.
Delete section if not applicable.
-->
---
.../cpython_benchmark/fory_benchmark.py | 30 ++++----
python/pyfory/_fory.py | 80 ++++++++++++++++----
python/pyfory/_registry.py | 27 +++++--
python/pyfory/_serialization.pyx | 88 ++++++++++++++++------
python/pyfory/tests/test_class_serializer.py | 14 ++--
python/pyfory/tests/test_cross_language.py | 40 +++++-----
python/pyfory/tests/test_meta_share.py | 42 ++++++-----
python/pyfory/tests/test_method.py | 40 +++++-----
python/pyfory/tests/test_reduce_serializer.py | 20 ++---
python/pyfory/tests/test_serializer.py | 80 +++++++++++---------
python/pyfory/tests/test_stateful_reproduction.py | 4 +-
python/pyfory/tests/test_stateful_serializer.py | 26 ++++---
python/pyfory/tests/test_struct.py | 22 +++---
python/pyfory/tests/test_typedef_encoding.py | 12 ++-
14 files changed, 331 insertions(+), 194 deletions(-)
diff --git a/integration_tests/cpython_benchmark/fory_benchmark.py
b/integration_tests/cpython_benchmark/fory_benchmark.py
index e2e5ae0d4..5b413a561 100644
--- a/integration_tests/cpython_benchmark/fory_benchmark.py
+++ b/integration_tests/cpython_benchmark/fory_benchmark.py
@@ -149,14 +149,14 @@ COMPLEX_OBJECT = ComplexObject1(
)
-def fory_object(language, ref_tracking, obj):
- fory = pyfory.Fory(language=language, ref_tracking=ref_tracking)
+def fory_object(xlang, ref, obj):
+ fory = pyfory.Fory(xlang=xlang, ref=ref)
binary = fory.serialize(obj)
fory.deserialize(binary)
-def fory_data_class(language, ref_tracking, obj, register_callable):
- fory = pyfory.Fory(language=language, ref_tracking=ref_tracking)
+def fory_data_class(xlang, ref, obj, register_callable):
+ fory = pyfory.Fory(xlang=xlang, ref=ref)
register_callable(fory)
binary = fory.serialize(obj)
fory.deserialize(binary)
@@ -183,35 +183,35 @@ def micro_benchmark():
os.environ["ENABLE_FORY_CYTHON_SERIALIZATION"] = "0"
sys.argv += ["--inherit-environ", "ENABLE_FORY_CYTHON_SERIALIZATION"]
runner.parse_args()
- language = pyfory.Language.XLANG if args.xlang else pyfory.Language.PYTHON
- runner.bench_func("fory_dict", fory_object, language, not args.no_ref,
DICT)
+ xlang = args.xlang
+ runner.bench_func("fory_dict", fory_object, xlang, not args.no_ref, DICT)
runner.bench_func(
- "fory_large_dict", fory_object, language, not args.no_ref, LARGE_DICT
+ "fory_large_dict", fory_object, xlang, not args.no_ref, LARGE_DICT
)
runner.bench_func(
- "fory_dict_group", fory_object, language, not args.no_ref, DICT_GROUP
+ "fory_dict_group", fory_object, xlang, not args.no_ref, DICT_GROUP
)
- runner.bench_func("fory_tuple", fory_object, language, not args.no_ref,
TUPLE)
+ runner.bench_func("fory_tuple", fory_object, xlang, not args.no_ref, TUPLE)
runner.bench_func(
- "fory_large_tuple", fory_object, language, not args.no_ref, LARGE_TUPLE
+ "fory_large_tuple", fory_object, xlang, not args.no_ref, LARGE_TUPLE
)
runner.bench_func(
"fory_large_float_tuple",
fory_object,
- language,
+ xlang,
not args.no_ref,
LARGE_FLOAT_TUPLE,
)
runner.bench_func(
"fory_large_boolean_tuple",
fory_object,
- language,
+ xlang,
not args.no_ref,
LARGE_BOOLEAN_TUPLE,
)
- runner.bench_func("fory_list", fory_object, language, not args.no_ref,
LIST)
+ runner.bench_func("fory_list", fory_object, xlang, not args.no_ref, LIST)
runner.bench_func(
- "fory_large_list", fory_object, language, not args.no_ref, LARGE_LIST
+ "fory_large_list", fory_object, xlang, not args.no_ref, LARGE_LIST
)
def register_complex(fory):
@@ -225,7 +225,7 @@ def micro_benchmark():
runner.bench_func(
"fory_complex",
fory_data_class,
- language,
+ xlang,
not args.no_ref,
COMPLEX_OBJECT,
register_complex,
diff --git a/python/pyfory/_fory.py b/python/pyfory/_fory.py
index 8c61ac04d..0df532355 100644
--- a/python/pyfory/_fory.py
+++ b/python/pyfory/_fory.py
@@ -99,7 +99,7 @@ class Fory:
"ref_resolver",
"type_resolver",
"serialization_context",
- "require_type_registration",
+ "strict",
"buffer",
"_buffer_callback",
"_buffers",
@@ -113,19 +113,34 @@ class Fory:
def __init__(
self,
- language=Language.PYTHON,
- ref_tracking: bool = False,
- require_type_registration: bool = True,
+ xlang: bool = False,
+ ref: bool = False,
+ strict: bool = True,
compatible: bool = False,
max_depth: int = 50,
+ **kwargs,
):
"""
- :param require_type_registration:
+ :param xlang:
+ Whether to enable cross-language serialization. When set to False,
enables Python-native
+ serialization supporting all serializable Python objects including
dataclasses,
+ structs, classes with
__getstate__/__setstate__/__reduce__/__reduce_ex__, local
+ functions/classes, and classes defined in IPython. With ref=True and
strict=False,
+ Fury can serve as a drop-in replacement for pickle and cloudpickle.
+ When set to True, serializes objects in cross-language format that can
+ be deserialized by other Fury-supported languages, but
Python-specific features
+ like functions/classes/methods and custom __reduce__ methods are not
supported.
+ :param ref:
+ Whether to enable reference tracking for shared and circular
references.
+ When enabled, duplicate objects will be stored only once and circular
references
+ are supported. Disabled by default for better performance.
+ :param strict:
Whether to require registering types for serialization, enabled by
default.
- If disabled, unknown insecure types can be deserialized, which can be
- insecure and cause remote code execution attack if the types
- `__new__`/`__init__`/`__eq__`/`__hash__` method contain malicious
code.
- Do not disable type registration if you can't ensure your
environment are
+ If disabled, unknown insecure types can be deserialized, which can be
+ insecure and cause remote code execution attack if the types
+ `__new__`/`__init__`/`__eq__`/`__hash__` method contain malicious
code, or you
+ are deserializing local functions/methods/classes.
+ Do not disable strict mode if you can't ensure your environment are
*indeed secure*. We are not responsible for security risks if
you disable this option.
:param compatible:
@@ -136,15 +151,21 @@ class Fory:
If the depth exceeds the maximum depth, an exception will be raised.
The default value is 50.
"""
- self.language = language
- self.is_py = language == Language.PYTHON
- self.require_type_registration = _ENABLE_TYPE_REGISTRATION_FORCIBLY or
require_type_registration
- self.compatible = compatible
- self.ref_tracking = ref_tracking
+ self.language = Language.XLANG if xlang else Language.PYTHON
+ if kwargs.get("language") is not None:
+ self.language = kwargs.get("language")
+ self.is_py = self.language == Language.PYTHON
+ if kwargs.get("ref_tracking") is not None:
+ ref = kwargs.get("ref_tracking")
+ self.ref_tracking = ref
if self.ref_tracking:
self.ref_resolver = MapRefResolver()
else:
self.ref_resolver = NoRefResolver()
+ if kwargs.get("require_type_registration") is not None:
+ strict = kwargs.get("require_type_registration")
+ self.strict = _ENABLE_TYPE_REGISTRATION_FORCIBLY or strict
+ self.compatible = compatible
from pyfory._serialization import MetaStringResolver,
SerializationContext
from pyfory._registry import TypeResolver
@@ -171,7 +192,13 @@ class Fory:
typename: str = None,
serializer=None,
):
- self.register_type(cls, type_id=type_id, namespace=namespace,
typename=typename, serializer=serializer)
+ self.register_type(
+ cls,
+ type_id=type_id,
+ namespace=namespace,
+ typename=typename,
+ serializer=serializer,
+ )
# `Union[type, TypeVar]` is not supported in py3.6
def register_type(
@@ -194,6 +221,29 @@ class Fory:
def register_serializer(self, cls: type, serializer):
self.type_resolver.register_serializer(cls, serializer)
+ def dumps(
+ self,
+ obj,
+ buffer: Buffer = None,
+ buffer_callback=None,
+ unsupported_callback=None,
+ ) -> Union[Buffer, bytes]:
+ """
+ Serialize an object to bytes, alias for `serialize` method.
+ """
+ return self.serialize(obj, buffer, buffer_callback,
unsupported_callback)
+
+ def loads(
+ self,
+ buffer: Union[Buffer, bytes],
+ buffers: Iterable = None,
+ unsupported_objects: Iterable = None,
+ ):
+ """
+ Deserialize bytes to an object, alias for `deserialize` method.
+ """
+ return self.deserialize(buffer, buffers, unsupported_objects)
+
def serialize(
self,
obj,
diff --git a/python/pyfory/_registry.py b/python/pyfory/_registry.py
index b1a714417..de64e25ee 100644
--- a/python/pyfory/_registry.py
+++ b/python/pyfory/_registry.py
@@ -177,7 +177,7 @@ class TypeResolver:
self.fory = fory
self.metastring_resolver = fory.metastring_resolver
self.language = fory.language
- self.require_registration = fory.require_type_registration
+ self.require_registration = fory.strict
self._metastr_to_str = dict()
self._metastr_to_type = dict()
self._hash_to_metastring = dict()
@@ -221,10 +221,19 @@ class TypeResolver:
ReduceSerializer: (self._stub_cls("__Reduce__"),
self._next_type_id()),
TypeSerializer: (self._stub_cls("__Type__"),
self._next_type_id()),
MethodSerializer: (self._stub_cls("__Method__"),
self._next_type_id()),
- FunctionSerializer: (self._stub_cls("__Function__"),
self._next_type_id()),
- NativeFuncMethodSerializer:
(self._stub_cls("__NativeFunction__"), self._next_type_id()),
+ FunctionSerializer: (
+ self._stub_cls("__Function__"),
+ self._next_type_id(),
+ ),
+ NativeFuncMethodSerializer: (
+ self._stub_cls("__NativeFunction__"),
+ self._next_type_id(),
+ ),
}
- for serializer, (stub_cls, type_id) in
self._internal_py_serializer_map.items():
+ for serializer, (
+ stub_cls,
+ type_id,
+ ) in self._internal_py_serializer_map.items():
register(stub_cls, serializer=serializer, type_id=type_id)
@staticmethod
@@ -725,7 +734,15 @@ class TypeResolver:
ns_meta_bytes = self.metastring_resolver.get_metastr_bytes(ns_metastr)
type_metastr = self.typename_encoder.encode(type_def.typename)
type_meta_bytes =
self.metastring_resolver.get_metastr_bytes(type_metastr)
- typeinfo = TypeInfo(type_def.cls, type_def.type_id, serializer,
ns_meta_bytes, type_meta_bytes, False, type_def)
+ typeinfo = TypeInfo(
+ type_def.cls,
+ type_def.type_id,
+ serializer,
+ ns_meta_bytes,
+ type_meta_bytes,
+ False,
+ type_def,
+ )
return typeinfo
def reset(self):
diff --git a/python/pyfory/_serialization.pyx b/python/pyfory/_serialization.pyx
index b468a485a..54b0d275a 100644
--- a/python/pyfory/_serialization.pyx
+++ b/python/pyfory/_serialization.pyx
@@ -99,9 +99,9 @@ cdef class MapRefResolver:
cdef object read_object
cdef c_bool ref_tracking
- def __cinit__(self, c_bool ref_tracking):
+ def __cinit__(self, c_bool ref):
self.read_object = None
- self.ref_tracking = ref_tracking
+ self.ref_tracking = ref
# Special methods of extension types must be declared with def, not cdef.
def __dealloc__(self):
@@ -801,7 +801,7 @@ cdef class SerializationContext:
cdef class Fory:
cdef readonly object language
cdef readonly c_bool ref_tracking
- cdef readonly c_bool require_type_registration
+ cdef readonly c_bool strict
cdef readonly c_bool is_py
cdef readonly c_bool compatible
cdef readonly MapRefResolver ref_resolver
@@ -819,37 +819,58 @@ cdef class Fory:
def __init__(
self,
- language=Language.PYTHON,
- ref_tracking: bool = False,
- require_type_registration: bool = True,
+ xlang: bool = False,
+ ref: bool = False,
+ strict: bool = True,
compatible: bool = False,
max_depth: int = 50,
+ **kwargs,
):
"""
- :param require_type_registration:
- Whether to require registering types for serialization, enabled by
default.
+ :param xlang:
+ Whether to enable cross-language serialization. When set to False,
enables Python-native
+ serialization supporting all serializable Python objects including
dataclasses,
+ structs, classes with
__getstate__/__setstate__/__reduce__/__reduce_ex__, local
+ functions/classes, and classes defined in IPython. With ref=True and
strict=False,
+ Fury can serve as a drop-in replacement for pickle and cloudpickle.
+ When set to True, serializes objects in cross-language format that can
+ be deserialized by other Fury-supported languages, but
Python-specific features
+ like functions/classes/methods and custom __reduce__ methods are not
supported.
+ :param ref:
+ Whether to enable reference tracking for shared and circular
references.
+ When enabled, duplicate objects will be stored only once and circular
references
+ are supported. Disabled by default for better performance.
+ :param strict:
+ Whether to require registering types for serialization, enabled by
default.
If disabled, unknown insecure types can be deserialized, which can be
insecure and cause remote code execution attack if the types
- `__new__`/`__init__`/`__eq__`/`__hash__` method contain malicious
code.
- Do not disable type registration if you can't ensure your
environment are
+ `__new__`/`__init__`/`__eq__`/`__hash__` method contain malicious
code, or you
+ are deserializing local functions/methods/classes.
+ Do not disable strict mode if you can't ensure your environment are
*indeed secure*. We are not responsible for security risks if
you disable this option.
- :param compatible:
- Whether to enable compatible mode for cross-language serialization.
+ :param compatible:
+ Whether to enable compatible mode for cross-language serialization.
When enabled, type forward/backward compatibility for struct fields
will be enabled.
- :param max_depth:
- The maximum depth of the deserialization data.
- If the depth exceeds the maximum depth, an exception will be raised.
- The default value is 50.
+ :param max_depth:
+ The maximum depth of the deserialization data.
+ If the depth exceeds the maximum depth, an exception will be raised.
+ The default value is 50.
"""
- self.language = language
- if _ENABLE_TYPE_REGISTRATION_FORCIBLY or require_type_registration:
- self.require_type_registration = True
+ self.language = Language.XLANG if xlang else Language.PYTHON
+ if kwargs.get("language") is not None:
+ self.language = kwargs.get("language")
+ if kwargs.get("ref_tracking") is not None:
+ ref = kwargs.get("ref_tracking")
+ if kwargs.get("require_type_registration") is not None:
+ strict = kwargs.get("require_type_registration")
+ if _ENABLE_TYPE_REGISTRATION_FORCIBLY or strict:
+ self.strict = True
else:
- self.require_type_registration = False
+ self.strict = False
self.compatible = compatible
- self.ref_tracking = ref_tracking
- self.ref_resolver = MapRefResolver(ref_tracking)
+ self.ref_tracking = ref
+ self.ref_resolver = MapRefResolver(ref)
self.is_py = self.language == Language.PYTHON
self.metastring_resolver = MetaStringResolver()
self.type_resolver = TypeResolver(self, meta_share=compatible)
@@ -891,6 +912,29 @@ cdef class Fory:
self.type_resolver.register_type(
cls, type_id=type_id, namespace=namespace, typename=typename,
serializer=serializer)
+ def dumps(
+ self,
+ obj,
+ buffer: Buffer = None,
+ buffer_callback=None,
+ unsupported_callback=None,
+ ) -> Union[Buffer, bytes]:
+ """
+ Serialize an object to bytes, alias for `serialize` method.
+ """
+ return self.serialize(obj, buffer, buffer_callback,
unsupported_callback)
+
+ def loads(
+ self,
+ buffer: Union[Buffer, bytes],
+ buffers: Iterable = None,
+ unsupported_objects: Iterable = None,
+ ):
+ """
+ Deserialize bytes to an object, alias for `deserialize` method.
+ """
+ return self.deserialize(buffer, buffers, unsupported_objects)
+
def serialize(
self, obj,
Buffer buffer=None,
diff --git a/python/pyfory/tests/test_class_serializer.py
b/python/pyfory/tests/test_class_serializer.py
index 2f903ef9d..e77e740b1 100644
--- a/python/pyfory/tests/test_class_serializer.py
+++ b/python/pyfory/tests/test_class_serializer.py
@@ -40,7 +40,7 @@ def test_local_class_serialization():
LocalClass = create_local_class()
# Test basic serialization of the class type itself
- fory = Fory(ref_tracking=True, require_type_registration=False)
+ fory = Fory(ref=True, strict=False)
# Serialize the class type
serialized = fory.serialize(LocalClass)
@@ -77,7 +77,7 @@ def test_local_class_with_closure():
# Create a local class with closure
LocalClassWithClosure = create_local_class_with_closure(3)
- fory = Fory(ref_tracking=True, require_type_registration=False)
+ fory = Fory(ref=True, strict=False)
# Serialize the class type
serialized = fory.serialize(LocalClassWithClosure)
@@ -114,7 +114,7 @@ def test_local_class_with_inheritance():
return LocalDerivedClass
LocalClass = create_local_class_with_inheritance()
- fory = Fory(ref_tracking=True, require_type_registration=False)
+ fory = Fory(ref=True, strict=False)
# Serialize and deserialize the class
serialized = fory.serialize(LocalClass)
@@ -155,7 +155,7 @@ def test_local_class_with_class_variables():
return LocalClassWithVars
LocalClass = create_class_with_vars()
- fory = Fory(ref_tracking=True, require_type_registration=False)
+ fory = Fory(ref=True, strict=False)
# Create some instances to modify class state
LocalClass(1) # This increments the counter
@@ -200,7 +200,7 @@ def test_nested_global_classes():
def create_inner(self, inner_val):
return self.InnerGlobalClass(inner_val)
- fory = Fory(ref_tracking=True, require_type_registration=False)
+ fory = Fory(ref=True, strict=False)
# Test serializing the outer class
serialized_outer = fory.serialize(OuterGlobalClass)
@@ -258,7 +258,7 @@ def test_complex_local_class_scenarios():
return OuterLocalClass
- fory = Fory(ref_tracking=True, require_type_registration=False)
+ fory = Fory(ref=True, strict=False)
# Create complex local class with nested closures
ComplexLocalClass = create_complex_local_scenario(5)
@@ -303,7 +303,7 @@ def test_local_class_with_multiple_inheritance():
return LocalMultipleInheritanceClass
- fory = Fory(ref_tracking=True, require_type_registration=False)
+ fory = Fory(ref=True, strict=False)
LocalClass = create_local_class_with_multiple_inheritance()
diff --git a/python/pyfory/tests/test_cross_language.py
b/python/pyfory/tests/test_cross_language.py
index 94206b59b..4523bdf17 100644
--- a/python/pyfory/tests/test_cross_language.py
+++ b/python/pyfory/tests/test_cross_language.py
@@ -275,7 +275,7 @@ def test_cross_language_serializer(data_file_path):
with open(data_file_path, "rb") as f:
data_bytes = f.read()
buffer = pyfory.Buffer(data_bytes)
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, ref=True)
objects = []
assert _deserialize_and_append(fory, buffer, objects) is True
assert _deserialize_and_append(fory, buffer, objects) is False
@@ -350,7 +350,7 @@ def test_cross_language_reference(data_file_path):
with open(data_file_path, "rb") as f:
data_bytes = f.read()
buffer = pyfory.Buffer(data_bytes)
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, ref=True)
new_list = fory.deserialize(buffer)
assert new_list[0] is new_list
new_map = new_list[1]
@@ -376,7 +376,7 @@ def test_serialize_arrow_in_band(data_file_path):
table = pa.Table.from_batches([batch] * 2)
data_bytes = f.read()
buffer = pyfory.Buffer(data_bytes)
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, ref=True)
new_batch = fory.deserialize(buffer)
assert new_batch == batch
new_table = fory.deserialize(buffer)
@@ -398,7 +398,7 @@ def test_serialize_arrow_out_of_band(int_band_file,
out_of_band_file):
out_of_band_buffer.slice(8, len1),
out_of_band_buffer.slice(8 + len1, len2),
]
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, ref=True)
objects = fory.deserialize(in_band_buffer, buffers=buffers)
assert objects == [batch, table]
buffer_objects = []
@@ -447,7 +447,7 @@ class ComplexObject2:
def test_serialize_simple_struct_local():
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, ref=True)
fory.register_type(ComplexObject2, namespace="test",
typename="ComplexObject2")
obj = ComplexObject2(f1=True, f2={-1: 2})
new_buf = fory.serialize(obj)
@@ -457,7 +457,7 @@ def test_serialize_simple_struct_local():
@cross_language_test
def test_serialize_simple_struct(data_file_path):
compatible = "compatible" in data_file_path
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True,
compatible=compatible)
+ fory = pyfory.Fory(xlang=True, ref=True, compatible=compatible)
fory.register_type(ComplexObject2, namespace="test",
typename="ComplexObject2")
obj = ComplexObject2(f1=True, f2={-1: 2})
struct_round_back(data_file_path, fory, obj)
@@ -466,7 +466,7 @@ def test_serialize_simple_struct(data_file_path):
@cross_language_test
def test_register_by_id(data_file_path):
compatible = "compatible" in data_file_path
- fory = pyfory.Fory(language=pyfory.XLANG, ref_tracking=True,
compatible=compatible)
+ fory = pyfory.Fory(xlang=True, ref=True, compatible=compatible)
fory.register_type(ComplexObject2, type_id=100)
obj = ComplexObject2(f1=True, f2={-1: 2})
struct_round_back(data_file_path, fory, obj)
@@ -479,7 +479,7 @@ class SomeClass:
def test_custom_class_roundtrip():
- fory = pyfory.Fory(ref_tracking=True)
+ fory = pyfory.Fory(ref=True)
fory.register_type(SomeClass, typename="example.SomeClass")
obj1 = SomeClass()
obj1.f2 = {"k1": "v1", "k2": "v2"}
@@ -516,7 +516,7 @@ class EnumFieldStruct:
@cross_language_test
def test_enum_field(data_file_path):
compatible = "compatible" in data_file_path
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=False,
compatible=compatible)
+ fory = pyfory.Fory(xlang=True, ref=False, compatible=compatible)
fory.register_type(EnumTestClass, namespace="test",
typename="EnumTestClass")
fory.register_type(EnumFieldStruct, namespace="test",
typename="EnumFieldStruct")
obj = EnumFieldStruct(f1=EnumTestClass.FOO, f2=EnumTestClass.BAR, f3="abc")
@@ -526,7 +526,7 @@ def test_enum_field(data_file_path):
@cross_language_test
def test_enum_field_register_by_id(data_file_path):
compatible = "compatible" in data_file_path
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=False,
compatible=compatible)
+ fory = pyfory.Fory(xlang=True, ref=False, compatible=compatible)
fory.register_type(EnumTestClass, type_id=1)
fory.register_type(EnumFieldStruct, type_id=2)
obj = EnumFieldStruct(f1=EnumTestClass.FOO, f2=EnumTestClass.BAR, f3="abc")
@@ -539,7 +539,7 @@ def test_struct_hash(data_file_path):
data_bytes = f.read()
debug_print(f"len {len(data_bytes)}")
read_hash = pyfory.Buffer(data_bytes).read_int32()
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, ref=True)
fory.register_type(ComplexObject1, typename="ComplexObject1")
serializer = fory.type_resolver.get_serializer(ComplexObject1)._replace()
from pyfory._struct import _get_hash
@@ -551,7 +551,7 @@ def test_struct_hash(data_file_path):
@cross_language_test
def test_serialize_complex_struct(data_file_path):
compatible = "compatible" in data_file_path
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True,
compatible=compatible)
+ fory = pyfory.Fory(xlang=True, ref=True, compatible=compatible)
fory.register_type(ComplexObject1, namespace="test",
typename="ComplexObject1")
fory.register_type(ComplexObject2, namespace="test",
typename="ComplexObject2")
@@ -616,7 +616,7 @@ def test_register_serializer(data_file_path):
data_bytes = f.read()
buffer = pyfory.Buffer(data_bytes)
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, ref=True)
fory.register_type(
ComplexObject1,
typename="test.ComplexObject1",
@@ -648,7 +648,7 @@ def test_oob_buffer(in_band_file_path,
out_of_band_file_path):
in_band_bytes = f.read()
with open(out_of_band_file_path, "rb") as f:
out_of_band_buffer = pyfory.Buffer(f.read())
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, ref=True)
n_buffers = out_of_band_buffer.read_int32()
buffers = []
for i in range(n_buffers):
@@ -691,7 +691,7 @@ def test_oob_buffer(in_band_file_path,
out_of_band_file_path):
@cross_language_test
def test_cross_language_meta_share(data_file_path):
"""Test cross-language meta sharing with ComplexObject2."""
- fory = pyfory.Fory(language=pyfory.Language.XLANG, compatible=True,
ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, compatible=True, ref=True)
@dataclass
class ComplexObject2:
@@ -730,7 +730,7 @@ def test_cross_language_meta_share(data_file_path):
@cross_language_test
def test_cross_language_meta_share_complex(data_file_path):
"""Test cross-language meta sharing with complex nested objects."""
- fory = pyfory.Fory(language=pyfory.Language.XLANG, compatible=True,
ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, compatible=True, ref=True)
@dataclass
class ComplexObject2:
@@ -787,7 +787,7 @@ def test_cross_language_meta_share_complex(data_file_path):
@cross_language_test
def test_schema_evolution(data_file_path):
"""Test schema evolution compatibility."""
- fory = pyfory.Fory(language=pyfory.Language.XLANG, compatible=True,
ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, compatible=True, ref=True)
# Same V1 class reading V1 data - should work perfectly
@dataclass
@@ -826,7 +826,7 @@ def test_schema_evolution(data_file_path):
@cross_language_test
def test_backward_compatibility(data_file_path):
"""Test backward compatibility - old version reading new data."""
- fory = pyfory.Fory(language=pyfory.Language.XLANG, compatible=True,
ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, compatible=True, ref=True)
# Version 1 class (original) reading Version 2 data (should ignore unknown
fields)
@dataclass
@@ -862,7 +862,7 @@ def test_backward_compatibility(data_file_path):
@cross_language_test
def test_field_reordering_compatibility(data_file_path):
"""Test field reordering compatibility in metashare mode."""
- fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True,
compatible=True)
+ fory = pyfory.Fory(xlang=True, ref=True, compatible=True)
# Version 3 class with reordered fields matching Java CompatTestV3
@dataclass
@@ -901,7 +901,7 @@ def test_field_reordering_compatibility(data_file_path):
@cross_language_test
def test_cross_version_compatibility(data_file_path):
"""Test mixed version compatibility."""
- fory = pyfory.Fory(language=pyfory.Language.XLANG, compatible=True,
ref_tracking=True)
+ fory = pyfory.Fory(xlang=True, compatible=True, ref=True)
@dataclass
class CompatTestV1:
diff --git a/python/pyfory/tests/test_meta_share.py
b/python/pyfory/tests/test_meta_share.py
index d405b24dc..024a6262c 100644
--- a/python/pyfory/tests/test_meta_share.py
+++ b/python/pyfory/tests/test_meta_share.py
@@ -17,7 +17,7 @@
import dataclasses
from typing import List, Dict
-from pyfory import Fory, Language
+from pyfory import Fory
import pyfory
@@ -96,19 +96,19 @@ class TestMetaShareMode:
def test_meta_share_enabled(self):
"""Test that meta share mode can be enabled."""
- fory = Fory(language=Language.XLANG, compatible=True)
+ fory = Fory(xlang=True, compatible=True)
assert fory.serialization_context.scoped_meta_share_enabled
assert fory.serialization_context.meta_context is not None
def test_meta_share_disabled(self):
"""Test that meta share mode can be disabled."""
- fory = Fory(language=Language.XLANG, compatible=False)
+ fory = Fory(xlang=True, compatible=False)
assert not fory.serialization_context.scoped_meta_share_enabled
assert fory.serialization_context.meta_context is None
def test_simple_dataclass_serialization(self):
"""Test serialization of simple dataclass with meta share."""
- fory = Fory(language=Language.XLANG, compatible=True)
+ fory = Fory(xlang=True, compatible=True)
# Register the dataclass
fory.register_type(SimpleDataClass)
@@ -124,7 +124,7 @@ class TestMetaShareMode:
def test_multiple_objects_same_type(self):
"""Test that multiple objects of same type reuse type definition."""
- fory = Fory(language=Language.XLANG, compatible=True)
+ fory = Fory(xlang=True, compatible=True)
# Register the dataclass
fory.register_type(SimpleDataClass)
@@ -137,7 +137,7 @@ class TestMetaShareMode:
buffer2 = fory.serialize(obj2)
# Create a new fory instance with the same meta context for
deserialization
- fory2 = Fory(language=Language.XLANG, compatible=True)
+ fory2 = Fory(xlang=True, compatible=True)
fory2.register_type(SimpleDataClass)
# Copy the meta context from the first fory instance
fory2.serialization_context.meta_context =
fory.serialization_context.meta_context
@@ -153,7 +153,7 @@ class TestMetaShareMode:
def test_simple_nested_dataclass_serialization(self):
"""Test serialization of simple nested dataclass with meta share."""
- fory = Fory(language=Language.XLANG, compatible=True)
+ fory = Fory(xlang=True, compatible=True)
# Register the dataclass
fory.register_type(SimpleNestedDataClass)
@@ -168,7 +168,7 @@ class TestMetaShareMode:
def test_serialization_without_meta_share(self):
"""Test that serialization works without meta share mode."""
- fory = Fory(language=Language.XLANG, compatible=False)
+ fory = Fory(xlang=True, compatible=False)
# Register the dataclass
fory.register_type(SimpleDataClass)
@@ -183,14 +183,14 @@ class TestMetaShareMode:
def test_schema_evolution_more_fields(self):
# Serialize with original schema
- fory1 = Fory(language=Language.XLANG, compatible=True)
+ fory1 = Fory(xlang=True, compatible=True)
fory1.register_type(SimpleDataClass)
obj = SimpleDataClass(name="test", age=25, active=True)
buffer = fory1.serialize(obj)
# Deserialize with extended schema (more fields)
- fory2 = Fory(language=Language.XLANG, compatible=True)
+ fory2 = Fory(xlang=True, compatible=True)
fory2.register_type(ExtendedDataClass)
deserialized = fory2.deserialize(buffer)
@@ -203,13 +203,13 @@ class TestMetaShareMode:
def test_schema_evolution_fewer_fields(self):
# Serialize with original schema
- fory1 = Fory(language=Language.XLANG, compatible=True)
+ fory1 = Fory(xlang=True, compatible=True)
fory1.register_type(SimpleDataClass)
obj = SimpleDataClass(name="test", age=25, active=True)
buffer = fory1.serialize(obj)
# Deserialize with reduced schema (fewer fields)
- fory2 = Fory(language=Language.XLANG, compatible=True)
+ fory2 = Fory(xlang=True, compatible=True)
fory2.register_type(ReducedDataClass)
deserialized = fory2.deserialize(buffer)
@@ -222,7 +222,7 @@ class TestMetaShareMode:
def test_schema_inconsistent_nested_struct(self):
"""Test schema inconsistency with nested struct types."""
# Serialize with original schema
- fory1 = Fory(language=Language.XLANG, compatible=True)
+ fory1 = Fory(xlang=True, compatible=True)
fory1.register_type(NestedStructClass)
fory1.register_type(SimpleNestedDataClass)
@@ -230,7 +230,7 @@ class TestMetaShareMode:
buffer = fory1.serialize(obj)
# Deserialize with inconsistent schema (different nested type)
- fory2 = Fory(language=Language.XLANG, compatible=True)
+ fory2 = Fory(xlang=True, compatible=True)
fory2.register_type(NestedStructClassInconsistent)
fory2.register_type(ExtendedDataClass)
@@ -244,14 +244,14 @@ class TestMetaShareMode:
def test_schema_inconsistent_list_fields(self):
"""Test schema inconsistency with List field types."""
# Serialize with original schema
- fory1 = Fory(language=Language.XLANG, compatible=True)
+ fory1 = Fory(xlang=True, compatible=True)
fory1.register_type(ListFieldsClass)
obj = ListFieldsClass(name="test", int_list=[1, 2, 3], str_list=["a",
"b", "c"])
buffer = fory1.serialize(obj)
# Deserialize with inconsistent schema (swapped List types)
- fory2 = Fory(language=Language.XLANG, compatible=True)
+ fory2 = Fory(xlang=True, compatible=True)
fory2.register_type(ListFieldsClassInconsistent)
# This should handle the schema inconsistency gracefully
@@ -265,14 +265,18 @@ class TestMetaShareMode:
def test_schema_inconsistent_dict_fields(self):
"""Test schema inconsistency with Dict field types."""
# Serialize with original schema
- fory1 = Fory(language=Language.XLANG, compatible=True)
+ fory1 = Fory(xlang=True, compatible=True)
fory1.register_type(DictFieldsClass)
- obj = DictFieldsClass(name="test", int_dict={"key1": 1, "key2": 2},
str_dict={"key1": "value1", "key2": "value2"})
+ obj = DictFieldsClass(
+ name="test",
+ int_dict={"key1": 1, "key2": 2},
+ str_dict={"key1": "value1", "key2": "value2"},
+ )
buffer = fory1.serialize(obj)
# Deserialize with inconsistent schema (swapped Dict value types)
- fory2 = Fory(language=Language.XLANG, compatible=True)
+ fory2 = Fory(xlang=True, compatible=True)
fory2.register_type(DictFieldsClassInconsistent)
# This should handle the schema inconsistency gracefully
diff --git a/python/pyfory/tests/test_method.py
b/python/pyfory/tests/test_method.py
index a1da596ed..cb3785751 100644
--- a/python/pyfory/tests/test_method.py
+++ b/python/pyfory/tests/test_method.py
@@ -75,7 +75,7 @@ class TestMethodSerialization:
def test_instance_method_serialization(self):
"""Test serialization of instance methods."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
class TestClass:
def __init__(self, value):
@@ -96,7 +96,7 @@ class TestMethodSerialization:
def test_classmethod_serialization(self):
"""Test serialization of class methods."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
class TestClass:
class_var = 42
@@ -116,7 +116,7 @@ class TestMethodSerialization:
def test_staticmethod_serialization(self):
"""Test serialization of static methods."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
class TestClass:
@staticmethod
@@ -134,7 +134,7 @@ class TestMethodSerialization:
def test_method_with_args_serialization(self):
"""Test serialization of methods with arguments."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
class TestClass:
def __init__(self, base):
@@ -176,7 +176,7 @@ class TestMethodSerialization:
def test_nested_class_method_serialization(self):
"""Test serialization of methods from nested classes."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
class OuterClass:
class InnerClass:
@@ -196,7 +196,7 @@ class TestMethodSerialization:
def test_classmethod_serialization():
"""Standalone test for classmethod serialization - reproduces the original
error."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
class A:
@classmethod
@@ -225,7 +225,7 @@ def test_classmethod_serialization():
def test_staticmethod_serialization():
"""Standalone test for staticmethod serialization."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
class A:
@staticmethod
@@ -243,7 +243,7 @@ def test_staticmethod_serialization():
# Global class method tests
def test_global_classmethod_serialization():
"""Test serialization of global class methods."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
method = GlobalTestClass.class_method
serialized = fory.serialize(method)
@@ -256,7 +256,7 @@ def test_global_classmethod_serialization():
def test_global_classmethod_with_args():
"""Test serialization of global class methods with arguments."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
method = GlobalTestClass.class_method_with_args
serialized = fory.serialize(method)
@@ -269,7 +269,7 @@ def test_global_classmethod_with_args():
def test_global_staticmethod_serialization():
"""Test serialization of global static methods."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
method = GlobalTestClass.static_method
serialized = fory.serialize(method)
@@ -281,7 +281,7 @@ def test_global_staticmethod_serialization():
def test_global_staticmethod_with_args():
"""Test serialization of global static methods with arguments."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
method = GlobalTestClass.static_method_with_args
serialized = fory.serialize(method)
@@ -294,7 +294,7 @@ def test_global_staticmethod_with_args():
def test_global_instance_method_serialization():
"""Test serialization of global instance methods."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
obj = GlobalTestClass("test_value")
method = obj.instance_method
@@ -307,7 +307,7 @@ def test_global_instance_method_serialization():
def test_multiple_global_classes():
"""Test serialization of methods from multiple global classes."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
# Test methods from different global classes
method1 = GlobalTestClass.class_method
@@ -327,7 +327,7 @@ def test_multiple_global_classes():
def test_global_class_inheritance():
"""Test serialization of methods from global classes with inheritance."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
# Test inherited class method
method = GlobalClassWithInheritance.inherited_class_method
@@ -348,7 +348,7 @@ def test_global_class_inheritance():
def test_global_methods_without_ref_tracking():
"""Test serialization of global class methods without reference
tracking."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=False)
+ fory = pyfory.Fory(strict=False, ref=False)
# Global classes should work even without ref_tracking
method = GlobalTestClass.class_method
@@ -361,9 +361,13 @@ def test_global_methods_without_ref_tracking():
def test_global_method_collection():
"""Test serialization of collections containing global methods."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
- methods = [GlobalTestClass.class_method, GlobalTestClass.static_method,
AnotherGlobalClass.another_class_method]
+ methods = [
+ GlobalTestClass.class_method,
+ GlobalTestClass.static_method,
+ AnotherGlobalClass.another_class_method,
+ ]
serialized = fory.serialize(methods)
deserialized = fory.deserialize(serialized)
@@ -375,7 +379,7 @@ def test_global_method_collection():
def test_global_method_in_dict():
"""Test serialization of dictionaries containing global methods."""
- fory = pyfory.Fory(require_type_registration=False, ref_tracking=True)
+ fory = pyfory.Fory(strict=False, ref=True)
method_dict = {
"class_method": GlobalTestClass.class_method,
diff --git a/python/pyfory/tests/test_reduce_serializer.py
b/python/pyfory/tests/test_reduce_serializer.py
index f8ecc34d9..9f6d7c3ed 100644
--- a/python/pyfory/tests/test_reduce_serializer.py
+++ b/python/pyfory/tests/test_reduce_serializer.py
@@ -15,7 +15,7 @@
# specific language governing permissions and limitations
# under the License.
-from pyfory import Fory, Language
+from pyfory import Fory
from pyfory.serializer import ReduceSerializer
@@ -137,7 +137,7 @@ class BothReduceAndStateful:
def test_basic_reduce_object():
"""Test basic __reduce__ functionality"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = BasicReduceObject(42, 3)
@@ -156,7 +156,7 @@ def test_basic_reduce_object():
def test_reduce_with_state_object():
"""Test __reduce__ with state"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = ReduceWithStateObject("test", {"key": "value"})
@@ -176,7 +176,7 @@ def test_reduce_with_state_object():
def test_reduce_ex_object():
"""Test __reduce_ex__ functionality"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = ReduceExObject(5, 7)
@@ -196,7 +196,7 @@ def test_reduce_ex_object():
def test_reduce_with_list_items():
"""Test __reduce__ with list items"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = ReduceWithListItems([1, 2, 3, 4])
@@ -215,7 +215,7 @@ def test_reduce_with_list_items():
def test_reduce_with_dict_items():
"""Test __reduce__ with dict items"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = ReduceWithDictItems({"a": 1, "b": 2})
@@ -234,7 +234,7 @@ def test_reduce_with_dict_items():
def test_reduce_precedence_over_stateful():
"""Test that ReduceSerializer has higher precedence than
StatefulSerializer"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = BothReduceAndStateful(100)
@@ -254,7 +254,7 @@ def test_reduce_precedence_over_stateful():
def test_reference_tracking():
"""Test that reference tracking works with ReduceSerializer"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj1 = BasicReduceObject(42)
obj2 = BasicReduceObject(42)
@@ -274,7 +274,7 @@ def test_reference_tracking():
def test_nested_reduce_objects():
"""Test nested objects with __reduce__"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
inner = BasicReduceObject(10, 2)
outer = ReduceWithStateObject("outer", {"inner": inner})
@@ -291,7 +291,7 @@ def test_nested_reduce_objects():
def test_cross_language_compatibility():
"""Test cross-language compatibility"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = BasicReduceObject(123, 4)
diff --git a/python/pyfory/tests/test_serializer.py
b/python/pyfory/tests/test_serializer.py
index b72321dcf..39743aa2e 100644
--- a/python/pyfory/tests/test_serializer.py
+++ b/python/pyfory/tests/test_serializer.py
@@ -49,7 +49,7 @@ pa = lazy_import("pyarrow")
def test_float():
- fory = Fory(language=Language.PYTHON, ref_tracking=True)
+ fory = Fory(xlang=False, ref=True)
assert ser_de(fory, -1.0) == -1.0
assert ser_de(fory, 1 / 3) == 1 / 3
serializer = fory.type_resolver.get_serializer(float)
@@ -57,13 +57,13 @@ def test_float():
def test_tuple():
- fory = Fory(language=Language.PYTHON, ref_tracking=True)
+ fory = Fory(xlang=False, ref=True)
print(len(fory.serialize((-1.0, 2))))
assert ser_de(fory, (-1.0, 2)) == (-1.0, 2)
def test_string():
- fory = Fory(language=Language.PYTHON, ref_tracking=True)
+ fory = Fory(xlang=False, ref=True)
assert ser_de(fory, "hello") == "hello"
assert ser_de(fory, "hello，世界") == "hello，世界"
assert ser_de(fory, "hello，世界" * 10) == "hello，世界" * 10
@@ -73,7 +73,7 @@ def test_string():
@pytest.mark.parametrize("track_ref", [False, True])
def test_dict(track_ref):
- fory = Fory(language=Language.PYTHON, ref_tracking=track_ref)
+ fory = Fory(xlang=False, ref=track_ref)
assert ser_de(fory, {1: 2}) == {1: 2}
assert ser_de(fory, {1 / 3: 2.0}) == {1 / 3: 2.0}
assert ser_de(fory, {1 / 3: 2}) == {1 / 3: 2}
@@ -95,7 +95,7 @@ def test_dict(track_ref):
@pytest.mark.parametrize("track_ref", [False, True])
def test_multi_chunk_simple_dict(track_ref):
- fory = Fory(language=Language.PYTHON, ref_tracking=track_ref)
+ fory = Fory(xlang=False, ref=track_ref)
dict0 = {
1: 2.0,
2: 3,
@@ -106,7 +106,7 @@ def test_multi_chunk_simple_dict(track_ref):
@pytest.mark.parametrize("track_ref", [False, True])
def test_multi_chunk_complex_dict(track_ref):
- fory = Fory(language=Language.PYTHON, ref_tracking=track_ref)
+ fory = Fory(xlang=False, ref=track_ref)
now = datetime.datetime.now()
day = datetime.date(2021, 11, 23)
dict0 = {"a": "a", 1: 1, -1.0: -1.0, True: True, now: now, day: day} #
noqa: F601
@@ -115,7 +115,7 @@ def test_multi_chunk_complex_dict(track_ref):
@pytest.mark.parametrize("track_ref", [False, True])
def test_big_chunk_dict(track_ref):
- fory = Fory(language=Language.PYTHON, ref_tracking=track_ref)
+ fory = Fory(xlang=False, ref=track_ref)
now = datetime.datetime.now()
day = datetime.date(2021, 11, 23)
dict0 = {}
@@ -129,7 +129,7 @@ def test_big_chunk_dict(track_ref):
@pytest.mark.parametrize("language", [Language.XLANG, Language.PYTHON])
def test_basic_serializer(language):
- fory = Fory(language=language, ref_tracking=True)
+ fory = Fory(language=language, ref=True)
typeinfo = fory.type_resolver.get_typeinfo(datetime.datetime)
assert isinstance(typeinfo.serializer, (TimestampSerializer,
_serialization.TimestampSerializer))
if language == Language.XLANG:
@@ -167,7 +167,7 @@ def test_basic_serializer(language):
@pytest.mark.parametrize("language", [Language.XLANG, Language.PYTHON])
def test_ref_tracking(language):
- fory = Fory(language=language, ref_tracking=True)
+ fory = Fory(language=language, ref=True)
simple_list = []
simple_list.append(simple_list)
@@ -204,7 +204,7 @@ def test_ref_tracking(language):
def test_tmp_ref(language):
# FIXME this can't simulate the case where new objects are allocated on
memory
# address of released tmp object.
- fory = Fory(language=language, ref_tracking=True)
+ fory = Fory(language=language, ref=True)
buffer = Buffer.allocate(128)
writer_index = buffer.writer_index
x = 1
@@ -228,7 +228,7 @@ def test_tmp_ref(language):
def test_multiple_ref(language):
# FIXME this can't simulate the case where new objects are allocated on
memory
# address of released tmp object.
- fory = Fory(language=language, ref_tracking=True)
+ fory = Fory(language=language, ref=True)
buffer = Buffer.allocate(128)
for i in range(1000):
fory.serialize([], buffer)
@@ -252,7 +252,7 @@ class RefTestClass2:
def test_ref_cleanup(language):
# FIXME this can't simulate the case where new objects are allocated on
memory
# address of released tmp object.
- fory = Fory(language=language, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(language=language, ref=True, strict=False)
# TODO support Language.XLANG, current unpickler will error for xlang,
o1 = RefTestClass1()
o2 = RefTestClass2(f1=o1)
@@ -269,7 +269,7 @@ def test_ref_cleanup(language):
@pytest.mark.parametrize("language", [Language.XLANG, Language.PYTHON])
def test_array_serializer(language):
- fory = Fory(language=language, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(language=language, ref=True, strict=False)
for typecode in PyArraySerializer.typecode_dict.keys():
arr = array.array(typecode, list(range(10)))
new_arr = ser_de(fory, arr)
@@ -343,7 +343,7 @@ def test_pickle():
def test_serialize_arrow():
record_batch = create_record_batch(10000)
table = pa.Table.from_batches([record_batch, record_batch])
- fory = Fory(language=Language.XLANG, ref_tracking=True)
+ fory = Fory(xlang=True, ref=True)
serialized_data = Buffer.allocate(32)
fory.serialize(record_batch, buffer=serialized_data)
fory.serialize(table, buffer=serialized_data)
@@ -358,7 +358,7 @@ def test_serialize_arrow_zero_copy():
record_batch = create_record_batch(10000)
table = pa.Table.from_batches([record_batch, record_batch])
buffer_objects = []
- fory = Fory(language=Language.XLANG, ref_tracking=True)
+ fory = Fory(xlang=True, ref=True)
serialized_data = Buffer.allocate(32)
fory.serialize(record_batch, buffer=serialized_data,
buffer_callback=buffer_objects.append)
fory.serialize(table, buffer=serialized_data,
buffer_callback=buffer_objects.append)
@@ -403,7 +403,7 @@ class RegisterClass:
def test_register_py_serializer():
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
class Serializer(pyfory.Serializer):
def write(self, buffer, value):
@@ -431,7 +431,7 @@ class A:
def test_register_type():
- fory = Fory(language=Language.PYTHON, ref_tracking=True)
+ fory = Fory(xlang=False, ref=True)
class Serializer(pyfory.Serializer):
def write(self, buffer, value):
@@ -455,7 +455,7 @@ def test_register_type():
def test_np_types():
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
o1 = [1, True, np.dtype(np.int32)]
data1 = fory.serialize(o1)
new_o1 = fory.deserialize(data1)
@@ -463,14 +463,14 @@ def test_np_types():
def test_pandas_dataframe():
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
df = pd.DataFrame({"a": list(range(10))})
df2 = fory.deserialize(fory.serialize(df))
assert df2.equals(df)
def test_unsupported_callback():
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
# Test with functions that now have proper serialization support
# Functions should no longer be treated as unsupported
@@ -498,7 +498,7 @@ def test_unsupported_callback():
def test_slice():
- fory = Fory(language=Language.PYTHON, ref_tracking=True)
+ fory = Fory(xlang=False, ref=True)
assert fory.deserialize(fory.serialize(slice(1, None, "10"))) == slice(1,
None, "10")
assert fory.deserialize(fory.serialize(slice(1, 100, 10))) == slice(1,
100, 10)
assert fory.deserialize(fory.serialize(slice(1, None, 10))) == slice(1,
None, 10)
@@ -530,7 +530,7 @@ class EnumClass(Enum):
def test_enum():
- fory = Fory(language=Language.PYTHON, ref_tracking=True)
+ fory = Fory(xlang=False, ref=True)
assert ser_de(fory, EnumClass.E1) == EnumClass.E1
assert ser_de(fory, EnumClass.E2) == EnumClass.E2
assert ser_de(fory, EnumClass.E3) == EnumClass.E3
@@ -539,7 +539,7 @@ def test_enum():
def test_duplicate_serialize():
- fory = Fory(language=Language.PYTHON, ref_tracking=True)
+ fory = Fory(xlang=False, ref=True)
assert ser_de(fory, EnumClass.E1) == EnumClass.E1
assert ser_de(fory, EnumClass.E2) == EnumClass.E2
assert ser_de(fory, EnumClass.E4) == EnumClass.E4
@@ -549,7 +549,7 @@ def test_duplicate_serialize():
def test_pandas_range_index():
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
fory.register_type(pd.RangeIndex,
serializer=pyfory.PandasRangeIndexSerializer(fory))
index = pd.RangeIndex(1, 100, 2, name="a")
new_index = ser_de(fory, index)
@@ -570,9 +570,9 @@ class PyDataClass1:
@pytest.mark.parametrize("track_ref", [False, True])
def test_py_serialize_dataclass(track_ref):
fory = Fory(
- language=Language.PYTHON,
- ref_tracking=track_ref,
- require_type_registration=False,
+ xlang=False,
+ ref=track_ref,
+ strict=False,
)
obj1 = PyDataClass1(f1=1, f2=-2.0, f3="abc", f4=True, f5="xyz", f6=[1, 2],
f7={"k1": "v1"})
assert ser_de(fory, obj1) == obj1
@@ -583,9 +583,9 @@ def test_py_serialize_dataclass(track_ref):
@pytest.mark.parametrize("track_ref", [False, True])
def test_function(track_ref):
fory = Fory(
- language=Language.PYTHON,
- ref_tracking=track_ref,
- require_type_registration=False,
+ xlang=False,
+ ref=track_ref,
+ strict=False,
)
c = fory.deserialize(fory.serialize(lambda x: x * 2))
assert c(2) == 4
@@ -616,9 +616,9 @@ class MapFields:
@pytest.mark.parametrize("track_ref", [False, True])
def test_map_fields_chunk_serializer(track_ref):
fory = Fory(
- language=Language.PYTHON,
- ref_tracking=track_ref,
- require_type_registration=False,
+ xlang=False,
+ ref=track_ref,
+ strict=False,
)
# Test case
@@ -690,9 +690,9 @@ class SomeTestSlotsObject:
@pytest.mark.parametrize("track_ref", [False, True])
def test_py_serialize_object(track_ref):
fory = Fory(
- language=Language.PYTHON,
- ref_tracking=track_ref,
- require_type_registration=False,
+ xlang=False,
+ ref=track_ref,
+ strict=False,
)
fory.register_type(SomeTestObject)
fory.register_type(SomeTestSlotsObject)
@@ -702,5 +702,13 @@ def test_py_serialize_object(track_ref):
assert ser_de(fory, obj2) == obj2
+def test_dumps_loads():
+ fory = Fory(xlang=False, ref=True)
+ obj = {"a": 1, "b": 2}
+ data = fory.dumps(obj)
+ new_obj = fory.loads(data)
+ assert obj == new_obj
+
+
if __name__ == "__main__":
test_string()
diff --git a/python/pyfory/tests/test_stateful_reproduction.py
b/python/pyfory/tests/test_stateful_reproduction.py
index 55628e5ca..fa6b06d1a 100644
--- a/python/pyfory/tests/test_stateful_reproduction.py
+++ b/python/pyfory/tests/test_stateful_reproduction.py
@@ -15,7 +15,7 @@
# specific language governing permissions and limitations
# under the License.
-from pyfory import Fory, Language
+from pyfory import Fory
# Test class with __getstate__ and __setstate__
@@ -101,7 +101,7 @@ class ImmutableOldStyle:
def test_current_behavior():
print("Testing current behavior with stateful objects...")
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
# Test basic stateful object
obj1 = StatefulObject(42, "original_secret")
diff --git a/python/pyfory/tests/test_stateful_serializer.py
b/python/pyfory/tests/test_stateful_serializer.py
index a91c49e38..246a7b061 100644
--- a/python/pyfory/tests/test_stateful_serializer.py
+++ b/python/pyfory/tests/test_stateful_serializer.py
@@ -16,7 +16,7 @@
# under the License.
import pytest
-from pyfory import Fory, Language
+from pyfory import Fory
from pyfory.serializer import StatefulSerializer
@@ -121,7 +121,11 @@ class ComplexStateObject:
self.count = len(self.items)
def __getstate__(self):
- return {"name": self.name, "items": self.items, "extra_info":
{"serialized_at": "test_time"}}
+ return {
+ "name": self.name,
+ "items": self.items,
+ "extra_info": {"serialized_at": "test_time"},
+ }
def __setstate__(self, state):
self.name = state["name"]
@@ -142,7 +146,7 @@ class ComplexStateObject:
def test_basic_stateful_object():
"""Test basic object with __getstate__ and __setstate__"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = BasicStatefulObject(42, "original_secret")
serialized = fory.serialize(obj)
@@ -161,7 +165,7 @@ def test_basic_stateful_object():
def test_immutable_with_getnewargs_ex():
"""Test object with __getnewargs_ex__"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = ImmutableWithArgsEx(10, 20, "test")
# Simulate the state that would be set by __setstate__ for comparison
@@ -184,7 +188,7 @@ def test_immutable_with_getnewargs_ex():
def test_immutable_with_getnewargs():
"""Test object with __getnewargs__ (old style)"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = ImmutableWithArgs(100, 200)
# Simulate the state that would be set by __setstate__ for comparison
@@ -206,7 +210,7 @@ def test_immutable_with_getnewargs():
def test_stateful_only_object():
"""Test object with only state methods, no constructor args"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = StatefulOnlyObject("test_data")
# Simulate the state that would be set by __setstate__ for comparison
@@ -227,7 +231,7 @@ def test_stateful_only_object():
def test_complex_state_object():
"""Test object with a complex nested state"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = ComplexStateObject("test", [1, 2, 3, {"nested": "value"}])
# Simulate the state that would be set by __setstate__ for comparison
@@ -250,7 +254,7 @@ def test_complex_state_object():
def test_reference_tracking():
"""Test that reference tracking works with StatefulSerializer"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = BasicStatefulObject(42)
# Create a list with the same object referenced twice
@@ -267,7 +271,7 @@ def test_reference_tracking():
def test_nested_stateful_objects():
"""Test serialization of nested stateful objects"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
inner = BasicStatefulObject(10)
outer = ComplexStateObject("outer", [inner, BasicStatefulObject(20)])
@@ -286,7 +290,7 @@ def test_nested_stateful_objects():
def test_cross_language_compatibility():
"""Test that StatefulSerializer works with type registration"""
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=True)
+ fory = Fory(xlang=False, ref=True, strict=True)
# Register the type explicitly
fory.register_type(BasicStatefulObject)
@@ -295,7 +299,7 @@ def test_cross_language_compatibility():
serialized = fory.serialize(obj)
# Deserialize with a new Fory instance that also has the type registered
- fory_new = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=True)
+ fory_new = Fory(xlang=False, ref=True, strict=True)
fory_new.register_type(BasicStatefulObject)
deserialized = fory_new.deserialize(serialized)
diff --git a/python/pyfory/tests/test_struct.py
b/python/pyfory/tests/test_struct.py
index 481382409..955c16fcc 100644
--- a/python/pyfory/tests/test_struct.py
+++ b/python/pyfory/tests/test_struct.py
@@ -23,7 +23,7 @@ import pytest
import typing
import pyfory
-from pyfory import Fory, Language
+from pyfory import Fory
from pyfory.error import TypeUnregisteredError
from pyfory.serializer import DataClassSerializer
@@ -53,7 +53,7 @@ class ComplexObject:
def test_struct():
- fory = Fory(language=Language.XLANG, ref_tracking=True)
+ fory = Fory(xlang=True, ref=True)
fory.register_type(SimpleObject, typename="SimpleObject")
fory.register_type(ComplexObject, typename="example.ComplexObject")
o = SimpleObject(f1={1: 1.0 / 3})
@@ -95,8 +95,8 @@ class ChildClass1(SuperClass1):
f3: Dict[str, pyfory.Float64Type] = None
-def test_require_type_registration():
- fory = Fory(language=Language.PYTHON, ref_tracking=True)
+def test_strict():
+ fory = Fory(xlang=False, ref=True)
obj = ChildClass1(f1="a", f2=-10, f3={"a": -10.0, "b": 1 / 3})
with pytest.raises(TypeUnregisteredError):
fory.serialize(obj)
@@ -106,7 +106,7 @@ def test_inheritance():
type_hints = typing.get_type_hints(ChildClass1)
print(type_hints)
assert type_hints.keys() == {"f1", "f2", "f3"}
- fory = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory = Fory(xlang=False, ref=True, strict=False)
obj = ChildClass1(f1="a", f2=-10, f3={"a": -10.0, "b": 1 / 3})
assert ser_de(fory, obj) == obj
assert type(fory.type_resolver.get_serializer(ChildClass1)) is
pyfory.DataClassSerializer
@@ -138,7 +138,7 @@ class DataClassObject:
def test_data_class_serializer_xlang():
- fory = Fory(language=Language.XLANG, ref_tracking=True)
+ fory = Fory(xlang=True, ref=True)
fory.register_type(ComplexObject, typename="example.ComplexObject")
fory.register_type(DataClassObject, typename="example.TestDataClassObject")
@@ -197,7 +197,7 @@ def test_data_class_serializer_xlang():
def test_data_class_serializer_xlang_codegen():
"""Test that DataClassSerializer generates xwrite/xread methods correctly
in xlang mode."""
- fory = Fory(language=Language.XLANG, ref_tracking=True)
+ fory = Fory(xlang=True, ref=True)
# Register types first
fory.register_type(ComplexObject, typename="example.ComplexObject")
@@ -262,7 +262,7 @@ def test_data_class_serializer_xlang_codegen_with_jit():
importlib.reload(pyfory.serializer)
- fory = Fory(language=Language.XLANG, ref_tracking=True)
+ fory = Fory(xlang=True, ref=True)
# Register types first
fory.register_type(ComplexObject, typename="example.ComplexObject")
@@ -314,7 +314,7 @@ def test_data_class_serializer_xlang_codegen_with_jit():
def test_data_class_serializer_xlang_codegen_generated_code():
"""Test that the generated code contains expected elements."""
- fory = Fory(language=Language.XLANG, ref_tracking=True)
+ fory = Fory(xlang=True, ref=True)
# Register types first
fory.register_type(ComplexObject, typename="example.ComplexObject")
@@ -351,8 +351,8 @@ def
test_data_class_serializer_xlang_codegen_generated_code():
def test_data_class_serializer_xlang_vs_non_xlang():
"""Test that xlang and non-xlang modes produce different serializers."""
- fory_xlang = Fory(language=Language.XLANG, ref_tracking=True)
- fory_python = Fory(language=Language.PYTHON, ref_tracking=True,
require_type_registration=False)
+ fory_xlang = Fory(xlang=True, ref=True)
+ fory_python = Fory(xlang=False, ref=True, strict=False)
# Register types for xlang
fory_xlang.register_type(ComplexObject, typename="example.ComplexObject")
diff --git a/python/pyfory/tests/test_typedef_encoding.py
b/python/pyfory/tests/test_typedef_encoding.py
index b53fa0986..c3029b691 100644
--- a/python/pyfory/tests/test_typedef_encoding.py
+++ b/python/pyfory/tests/test_typedef_encoding.py
@@ -21,9 +21,15 @@ Tests for xlang TypeDef implementation.
from dataclasses import dataclass
from typing import List, Dict
-import pyfory
from pyfory._util import Buffer
-from pyfory.meta.typedef import TypeDef, FieldInfo, FieldType,
CollectionFieldType, MapFieldType, DynamicFieldType
+from pyfory.meta.typedef import (
+ TypeDef,
+ FieldInfo,
+ FieldType,
+ CollectionFieldType,
+ MapFieldType,
+ DynamicFieldType,
+)
from pyfory.meta.typedef_encoder import encode_typedef
from pyfory.meta.typedef_decoder import decode_typedef
from pyfory.type import TypeId
@@ -107,7 +113,7 @@ def test_dynamic_field_type():
def test_encode_decode_typedef():
"""Test encoding and decoding a TypeDef."""
- fory = Fory(language=pyfory.XLANG)
+ fory = Fory(xlang=True)
fory.register(SimpleTypeDef, namespace="example", typename="SimpleTypeDef")
fory.register(TestTypeDef, namespace="example", typename="TestTypeDef")
# Create a mock resolver
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
