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 bb5117ef feat(python): replace "_class" prefix with "_type" in
metashare (#2290)
bb5117ef is described below
commit bb5117ef27569de44a85f51899ab993fec86b852
Author: urlyy <[email protected]>
AuthorDate: Wed Jun 4 10:39:42 2025 +0800
feat(python): replace "_class" prefix with "_type" in metashare (#2290)
## What does this PR do?
replace "_class" prefix with "_type" in metashare
## Related issues
#2289
## Does this PR introduce any user-facing change?
- [ ] Does this PR introduce any public API change?
- [ ] Does this PR introduce any binary protocol compatibility change?
---
python/pyfory/__init__.py | 4 +-
python/pyfory/_fory.py | 126 ++++-----
python/pyfory/_registry.py | 160 ++++++-----
python/pyfory/_serialization.pyx | 432 ++++++++++++++---------------
python/pyfory/_serializer.py | 90 +++---
python/pyfory/_struct.py | 40 ++-
python/pyfory/error.py | 2 +-
python/pyfory/format/infer.py | 10 +-
python/pyfory/serializer.py | 16 +-
python/pyfory/tests/test_cross_language.py | 2 +-
python/pyfory/tests/test_serializer.py | 34 +--
python/pyfory/tests/test_struct.py | 6 +-
12 files changed, 459 insertions(+), 463 deletions(-)
diff --git a/python/pyfory/__init__.py b/python/pyfory/__init__.py
index 081dc736..fad053c0 100644
--- a/python/pyfory/__init__.py
+++ b/python/pyfory/__init__.py
@@ -26,10 +26,10 @@ try:
except ImportError:
ENABLE_FORY_CYTHON_SERIALIZATION = False
-from pyfory._registry import ClassInfo
+from pyfory._registry import TypeInfo
if ENABLE_FORY_CYTHON_SERIALIZATION:
- from pyfory._serialization import Fory, ClassInfo # noqa: F401,F811
+ from pyfory._serialization import Fory, TypeInfo # noqa: F401,F811
from pyfory._struct import ( # noqa: F401,F403,F811 # pylint:
disable=unused-import
ComplexObjectSerializer,
diff --git a/python/pyfory/_fory.py b/python/pyfory/_fory.py
index 135266fb..86e83641 100644
--- a/python/pyfory/_fory.py
+++ b/python/pyfory/_fory.py
@@ -47,19 +47,19 @@ logger = logging.getLogger(__name__)
MAGIC_NUMBER = 0x62D4
DEFAULT_DYNAMIC_WRITE_META_STR_ID = -1
DYNAMIC_TYPE_ID = -1
-USE_CLASSNAME = 0
-USE_CLASS_ID = 1
-# preserve 0 as flag for class id not set in ClassInfo`
-NO_CLASS_ID = 0
-INT64_CLASS_ID = TypeId.INT64
-FLOAT64_CLASS_ID = TypeId.FLOAT64
-BOOL_CLASS_ID = TypeId.BOOL
-STRING_CLASS_ID = TypeId.STRING
-# `NOT_NULL_VALUE_FLAG` + `CLASS_ID << 1` in little-endian order
-NOT_NULL_INT64_FLAG = NOT_NULL_VALUE_FLAG & 0b11111111 | (INT64_CLASS_ID << 8)
-NOT_NULL_FLOAT64_FLAG = NOT_NULL_VALUE_FLAG & 0b11111111 | (FLOAT64_CLASS_ID
<< 8)
-NOT_NULL_BOOL_FLAG = NOT_NULL_VALUE_FLAG & 0b11111111 | (BOOL_CLASS_ID << 8)
-NOT_NULL_STRING_FLAG = NOT_NULL_VALUE_FLAG & 0b11111111 | (STRING_CLASS_ID <<
8)
+USE_TYPE_NAME = 0
+USE_TYPE_ID = 1
+# preserve 0 as flag for type id not set in TypeInfo`
+NO_TYPE_ID = 0
+INT64_TYPE_ID = TypeId.INT64
+FLOAT64_TYPE_ID = TypeId.FLOAT64
+BOOL_TYPE_ID = TypeId.BOOL
+STRING_TYPE_ID = TypeId.STRING
+# `NOT_NULL_VALUE_FLAG` + `TYPE_ID << 1` in little-endian order
+NOT_NULL_INT64_FLAG = NOT_NULL_VALUE_FLAG & 0b11111111 | (INT64_TYPE_ID << 8)
+NOT_NULL_FLOAT64_FLAG = NOT_NULL_VALUE_FLAG & 0b11111111 | (FLOAT64_TYPE_ID <<
8)
+NOT_NULL_BOOL_FLAG = NOT_NULL_VALUE_FLAG & 0b11111111 | (BOOL_TYPE_ID << 8)
+NOT_NULL_STRING_FLAG = NOT_NULL_VALUE_FLAG & 0b11111111 | (STRING_TYPE_ID << 8)
SMALL_STRING_THRESHOLD = 16
@@ -100,9 +100,9 @@ class Fory:
"is_py",
"ref_tracking",
"ref_resolver",
- "class_resolver",
+ "type_resolver",
"serialization_context",
- "require_class_registration",
+ "require_type_registration",
"buffer",
"pickler",
"unpickler",
@@ -119,22 +119,22 @@ class Fory:
self,
language=Language.XLANG,
ref_tracking: bool = False,
- require_class_registration: bool = True,
+ require_type_registration: bool = True,
):
"""
- :param require_class_registration:
- Whether to require registering classes for serialization, enabled by
default.
- If disabled, unknown insecure classes can be deserialized, which can
be
- insecure and cause remote code execution attack if the classes
+ :param require_type_registration:
+ 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 class registration if you can't ensure your
environment are
+ Do not disable type registration if you can't ensure your
environment are
*indeed secure*. We are not responsible for security risks if
you disable this option.
"""
self.language = language
self.is_py = language == Language.PYTHON
- self.require_class_registration = (
- _ENABLE_CLASS_REGISTRATION_FORCIBLY or require_class_registration
+ self.require_type_registration = (
+ _ENABLE_TYPE_REGISTRATION_FORCIBLY or require_type_registration
)
self.ref_tracking = ref_tracking
if self.ref_tracking:
@@ -142,16 +142,16 @@ class Fory:
else:
self.ref_resolver = NoRefResolver()
from pyfory._serialization import MetaStringResolver
- from pyfory._registry import ClassResolver
+ from pyfory._registry import TypeResolver
self.metastring_resolver = MetaStringResolver()
- self.class_resolver = ClassResolver(self)
- self.class_resolver.initialize()
+ self.type_resolver = TypeResolver(self)
+ self.type_resolver.initialize()
self.serialization_context = SerializationContext()
self.buffer = Buffer.allocate(32)
- if not require_class_registration:
+ if not require_type_registration:
warnings.warn(
- "Class registration is disabled, unknown classes can be
deserialized "
+ "Type registration is disabled, unknown types can be
deserialized "
"which may be insecure.",
RuntimeWarning,
stacklevel=2,
@@ -168,7 +168,7 @@ class Fory:
self._peer_language = None
def register_serializer(self, cls: type, serializer):
- self.class_resolver.register_serializer(cls, serializer)
+ self.type_resolver.register_serializer(cls, serializer)
# `Union[type, TypeVar]` is not supported in py3.6
def register_type(
@@ -180,7 +180,7 @@ class Fory:
typename: str = None,
serializer=None,
):
- return self.class_resolver.register_type(
+ return self.type_resolver.register_type(
cls,
type_id=type_id,
namespace=namespace,
@@ -257,7 +257,7 @@ class Fory:
else:
return buffer.to_bytes(0, buffer.writer_index)
- def serialize_ref(self, buffer, obj, classinfo=None):
+ def serialize_ref(self, buffer, obj, typeinfo=None):
cls = type(obj)
if cls is str:
buffer.write_int16(NOT_NULL_STRING_FLAG)
@@ -273,29 +273,29 @@ class Fory:
return
if self.ref_resolver.write_ref_or_null(buffer, obj):
return
- if classinfo is None:
- classinfo = self.class_resolver.get_classinfo(cls)
- self.class_resolver.write_typeinfo(buffer, classinfo)
- classinfo.serializer.write(buffer, obj)
+ if typeinfo is None:
+ typeinfo = self.type_resolver.get_typeinfo(cls)
+ self.type_resolver.write_typeinfo(buffer, typeinfo)
+ typeinfo.serializer.write(buffer, obj)
def serialize_nonref(self, buffer, obj):
cls = type(obj)
if cls is str:
- buffer.write_varuint32(STRING_CLASS_ID)
+ buffer.write_varuint32(STRING_TYPE_ID)
buffer.write_string(obj)
return
elif cls is int:
- buffer.write_varuint32(INT64_CLASS_ID)
+ buffer.write_varuint32(INT64_TYPE_ID)
buffer.write_varint64(obj)
return
elif cls is bool:
- buffer.write_varuint32(BOOL_CLASS_ID)
+ buffer.write_varuint32(BOOL_TYPE_ID)
buffer.write_bool(obj)
return
else:
- classinfo = self.class_resolver.get_classinfo(cls)
- self.class_resolver.write_typeinfo(buffer, classinfo)
- classinfo.serializer.write(buffer, obj)
+ typeinfo = self.type_resolver.get_typeinfo(cls)
+ self.type_resolver.write_typeinfo(buffer, typeinfo)
+ typeinfo.serializer.write(buffer, obj)
def xserialize_ref(self, buffer, obj, serializer=None):
if serializer is None or serializer.need_to_write_ref:
@@ -313,9 +313,9 @@ class Fory:
serializer.xwrite(buffer, obj)
return
cls = type(obj)
- classinfo = self.class_resolver.get_classinfo(cls)
- self.class_resolver.write_typeinfo(buffer, classinfo)
- classinfo.serializer.xwrite(buffer, obj)
+ typeinfo = self.type_resolver.get_typeinfo(cls)
+ self.type_resolver.write_typeinfo(buffer, typeinfo)
+ typeinfo.serializer.xwrite(buffer, obj)
def deserialize(
self,
@@ -381,8 +381,8 @@ class Fory:
ref_id = ref_resolver.try_preserve_ref_id(buffer)
# indicates that the object is first read.
if ref_id >= NOT_NULL_VALUE_FLAG:
- classinfo = self.class_resolver.read_typeinfo(buffer)
- o = classinfo.serializer.read(buffer)
+ typeinfo = self.type_resolver.read_typeinfo(buffer)
+ o = typeinfo.serializer.read(buffer)
ref_resolver.set_read_object(ref_id, o)
return o
else:
@@ -390,8 +390,8 @@ class Fory:
def deserialize_nonref(self, buffer):
"""Deserialize not-null and non-reference object from buffer."""
- classinfo = self.class_resolver.read_typeinfo(buffer)
- return classinfo.serializer.read(buffer)
+ typeinfo = self.type_resolver.read_typeinfo(buffer)
+ return typeinfo.serializer.read(buffer)
def xdeserialize_ref(self, buffer, serializer=None):
if serializer is None or serializer.need_to_write_ref:
@@ -411,7 +411,7 @@ class Fory:
def xdeserialize_nonref(self, buffer, serializer=None):
if serializer is None:
- serializer = self.class_resolver.read_typeinfo(buffer).serializer
+ serializer = self.type_resolver.read_typeinfo(buffer).serializer
return serializer.xread(buffer)
def write_buffer_object(self, buffer, buffer_object: BufferObject):
@@ -457,20 +457,20 @@ class Fory:
assert self._unsupported_objects is not None
return next(self._unsupported_objects)
- def write_ref_pyobject(self, buffer, value, classinfo=None):
+ def write_ref_pyobject(self, buffer, value, typeinfo=None):
if self.ref_resolver.write_ref_or_null(buffer, value):
return
- if classinfo is None:
- classinfo = self.class_resolver.get_classinfo(type(value))
- self.class_resolver.write_typeinfo(buffer, classinfo)
- classinfo.serializer.write(buffer, value)
+ if typeinfo is None:
+ typeinfo = self.type_resolver.get_typeinfo(type(value))
+ self.type_resolver.write_typeinfo(buffer, typeinfo)
+ typeinfo.serializer.write(buffer, value)
def read_ref_pyobject(self, buffer):
return self.deserialize_ref(buffer)
def reset_write(self):
self.ref_resolver.reset_write()
- self.class_resolver.reset_write()
+ self.type_resolver.reset_write()
self.serialization_context.reset()
self.metastring_resolver.reset_write()
self.pickler.clear_memo()
@@ -479,7 +479,7 @@ class Fory:
def reset_read(self):
self.ref_resolver.reset_read()
- self.class_resolver.reset_read()
+ self.type_resolver.reset_read()
self.serialization_context.reset()
self.metastring_resolver.reset_write()
self.unpickler = None
@@ -521,8 +521,8 @@ class SerializationContext:
self.objects.clear()
-_ENABLE_CLASS_REGISTRATION_FORCIBLY = os.getenv(
- "ENABLE_CLASS_REGISTRATION_FORCIBLY", "0"
+_ENABLE_TYPE_REGISTRATION_FORCIBLY = os.getenv(
+ "ENABLE_TYPE_REGISTRATION_FORCIBLY", "0"
) in {
"1",
"true",
@@ -532,9 +532,9 @@ _ENABLE_CLASS_REGISTRATION_FORCIBLY = os.getenv(
class _PicklerStub:
def dump(self, o):
raise ValueError(
- f"Class {type(o)} is not registered, "
- f"pickle is not allowed when class registration enabled, Please
register"
- f"the class or pass unsupported_callback"
+ f"Type {type(o)} is not registered, "
+ f"pickle is not allowed when type registration enabled, Please
register"
+ f"the type or pass unsupported_callback"
)
def clear_memo(self):
@@ -544,6 +544,6 @@ class _PicklerStub:
class _UnpicklerStub:
def load(self):
raise ValueError(
- "pickle is not allowed when class registration enabled, Please
register"
- "the class or pass unsupported_callback"
+ "pickle is not allowed when type registration enabled, Please
register"
+ "the type or pass unsupported_callback"
)
diff --git a/python/pyfory/_registry.py b/python/pyfory/_registry.py
index 47ca1b72..6c3790c8 100644
--- a/python/pyfory/_registry.py
+++ b/python/pyfory/_registry.py
@@ -74,8 +74,8 @@ from pyfory.type import (
)
from pyfory._fory import (
DYNAMIC_TYPE_ID,
- # preserve 0 as flag for class id not set in ClassInfo`
- NO_CLASS_ID,
+ # preserve 0 as flag for type id not set in TypeInfo`
+ NO_TYPE_ID,
)
try:
@@ -87,10 +87,10 @@ logger = logging.getLogger(__name__)
if ENABLE_FORY_CYTHON_SERIALIZATION:
- from pyfory._serialization import ClassInfo
+ from pyfory._serialization import TypeInfo
else:
- class ClassInfo:
+ class TypeInfo:
__slots__ = (
"cls",
"type_id",
@@ -103,7 +103,7 @@ else:
def __init__(
self,
cls: type = None,
- type_id: int = NO_CLASS_ID,
+ type_id: int = NO_TYPE_ID,
serializer: Serializer = None,
namespace_bytes=None,
typename_bytes=None,
@@ -118,26 +118,26 @@ else:
def __repr__(self):
return (
- f"ClassInfo(cls={self.cls}, type_id={self.type_id}, "
+ f"TypeInfo(cls={self.cls}, type_id={self.type_id}, "
f"serializer={self.serializer})"
)
-class ClassResolver:
+class TypeResolver:
__slots__ = (
"fory",
"_metastr_to_str",
"_type_id_counter",
- "_classes_info",
+ "_types_info",
"_hash_to_metastring",
- "_metastr_to_class",
- "_hash_to_classinfo",
- "_dynamic_id_to_classinfo_list",
+ "_metastr_to_type",
+ "_hash_to_typeinfo",
+ "_dynamic_id_to_typeinfo_list",
"_dynamic_id_to_metastr_list",
"_dynamic_write_string_id",
"_dynamic_written_metastr",
- "_ns_type_to_classinfo",
- "_named_type_to_classinfo",
+ "_ns_type_to_typeinfo",
+ "_named_type_to_typeinfo",
"namespace_encoder",
"namespace_decoder",
"typename_encoder",
@@ -145,27 +145,27 @@ class ClassResolver:
"require_registration",
"metastring_resolver",
"language",
- "_type_id_to_classinfo",
+ "_type_id_to_typeinfo",
)
def __init__(self, fory):
self.fory = fory
self.metastring_resolver = fory.metastring_resolver
self.language = fory.language
- self.require_registration = fory.require_class_registration
+ self.require_registration = fory.require_type_registration
self._metastr_to_str = dict()
- self._metastr_to_class = dict()
+ self._metastr_to_type = dict()
self._hash_to_metastring = dict()
- self._hash_to_classinfo = dict()
+ self._hash_to_typeinfo = dict()
self._dynamic_written_metastr = []
- self._type_id_to_classinfo = dict()
+ self._type_id_to_typeinfo = dict()
self._type_id_counter = 64
self._dynamic_write_string_id = 0
# hold objects to avoid gc, since `flat_hash_map/vector` doesn't
# hold python reference.
- self._classes_info = dict()
- self._ns_type_to_classinfo = dict()
- self._named_type_to_classinfo = dict()
+ self._types_info = dict()
+ self._ns_type_to_typeinfo = dict()
+ self._named_type_to_typeinfo = dict()
self.namespace_encoder = MetaStringEncoder(".", "_")
self.namespace_decoder = MetaStringDecoder(".", "_")
self.typename_encoder = MetaStringEncoder("$", "_")
@@ -180,7 +180,7 @@ class ClassResolver:
register = functools.partial(self._register_type, internal=True)
register(
_PickleStub,
- type_id=PickleSerializer.PICKLE_CLASS_ID,
+ type_id=PickleSerializer.PICKLE_TYPE_ID,
serializer=PickleSerializer,
)
register(
@@ -297,7 +297,7 @@ class ClassResolver:
serializer=None,
internal=False,
):
- """Register class with given type id or typename. If typename is not
None, it will be used for
+ """Register type with given type id or typename. If typename is not
None, it will be used for
cross-language serialization."""
if serializer is not None and not isinstance(serializer, Serializer):
try:
@@ -315,10 +315,10 @@ class ClassResolver:
f"type name {typename} and id {type_id} should not be set at
the same time"
)
if type_id not in {0, None}:
- # multiple class can have same tpe id
- if type_id in self._type_id_to_classinfo and cls in
self._classes_info:
+ # multiple type can have same tpe id
+ if type_id in self._type_id_to_typeinfo and cls in
self._types_info:
raise TypeError(f"{cls} registered already")
- elif cls in self._classes_info:
+ elif cls in self._types_info:
raise TypeError(f"{cls} registered already")
register_type = (
self._register_xtype
@@ -405,7 +405,7 @@ class ClassResolver:
if not internal and serializer is None:
serializer = self._create_serializer(cls)
if typename is None:
- classinfo = ClassInfo(cls, type_id, serializer, None, None,
dynamic_type)
+ typeinfo = TypeInfo(cls, type_id, serializer, None, None,
dynamic_type)
else:
if namespace is None:
splits = typename.rsplit(".", 1)
@@ -415,71 +415,71 @@ class ClassResolver:
ns_meta_bytes =
self.metastring_resolver.get_metastr_bytes(ns_metastr)
type_metastr = self.typename_encoder.encode(typename)
type_meta_bytes =
self.metastring_resolver.get_metastr_bytes(type_metastr)
- classinfo = ClassInfo(
+ typeinfo = TypeInfo(
cls, type_id, serializer, ns_meta_bytes, type_meta_bytes,
dynamic_type
)
- self._named_type_to_classinfo[(namespace, typename)] = classinfo
- self._ns_type_to_classinfo[(ns_meta_bytes, type_meta_bytes)] =
classinfo
- self._classes_info[cls] = classinfo
+ self._named_type_to_typeinfo[(namespace, typename)] = typeinfo
+ self._ns_type_to_typeinfo[(ns_meta_bytes, type_meta_bytes)] =
typeinfo
+ self._types_info[cls] = typeinfo
if type_id > 0 and (
self.language == Language.PYTHON or not
TypeId.is_namespaced_type(type_id)
):
- if type_id not in self._type_id_to_classinfo or not internal:
- self._type_id_to_classinfo[type_id] = classinfo
- self._classes_info[cls] = classinfo
- return classinfo
+ if type_id not in self._type_id_to_typeinfo or not internal:
+ self._type_id_to_typeinfo[type_id] = typeinfo
+ self._types_info[cls] = typeinfo
+ return typeinfo
def _next_type_id(self):
type_id = self._type_id_counter = self._type_id_counter + 1
- while type_id in self._type_id_to_classinfo:
+ while type_id in self._type_id_to_typeinfo:
type_id = self._type_id_counter = self._type_id_counter + 1
return type_id
def register_serializer(self, cls: Union[type, TypeVar], serializer):
assert isinstance(cls, (type, TypeVar)), cls
- if cls not in self._classes_info:
+ if cls not in self._types_info:
raise TypeUnregisteredError(f"{cls} not registered")
- classinfo = self._classes_info[cls]
+ typeinfo = self._types_info[cls]
if self.fory.language == Language.PYTHON:
- classinfo.serializer = serializer
+ typeinfo.serializer = serializer
return
- type_id = prev_type_id = classinfo.type_id
- self._type_id_to_classinfo.pop(prev_type_id)
- if classinfo.serializer is not serializer:
- if classinfo.typename_bytes is not None:
- type_id = classinfo.type_id & 0xFFFFFF00 | TypeId.NAMED_EXT
+ type_id = prev_type_id = typeinfo.type_id
+ self._type_id_to_typeinfo.pop(prev_type_id)
+ if typeinfo.serializer is not serializer:
+ if typeinfo.typename_bytes is not None:
+ type_id = typeinfo.type_id & 0xFFFFFF00 | TypeId.NAMED_EXT
else:
- type_id = classinfo.type_id & 0xFFFFFF00 | TypeId.EXT
- self._type_id_to_classinfo[type_id] = classinfo
+ type_id = typeinfo.type_id & 0xFFFFFF00 | TypeId.EXT
+ self._type_id_to_typeinfo[type_id] = typeinfo
def get_serializer(self, cls: type):
"""
Returns
-------
- Returns or create serializer for the provided class
+ Returns or create serializer for the provided type
"""
- return self.get_classinfo(cls).serializer
-
- def get_classinfo(self, cls, create=True):
- class_info = self._classes_info.get(cls)
- if class_info is not None:
- if class_info.serializer is None:
- class_info.serializer = self._create_serializer(cls)
- return class_info
+ return self.get_typeinfo(cls).serializer
+
+ def get_typeinfo(self, cls, create=True):
+ type_info = self._types_info.get(cls)
+ if type_info is not None:
+ if type_info.serializer is None:
+ type_info.serializer = self._create_serializer(cls)
+ return type_info
elif not create:
return None
if self.language != Language.PYTHON or (
self.require_registration and not issubclass(cls, Enum)
):
raise TypeUnregisteredError(f"{cls} not registered")
- logger.info("Class %s not registered", cls)
+ logger.info("Type %s not registered", cls)
serializer = self._create_serializer(cls)
type_id = None
if self.language == Language.PYTHON:
if isinstance(serializer, EnumSerializer):
type_id = TypeId.NAMED_ENUM
elif type(serializer) is PickleSerializer:
- type_id = PickleSerializer.PICKLE_CLASS_ID
+ type_id = PickleSerializer.PICKLE_TYPE_ID
if not self.require_registration:
if isinstance(serializer, DataClassSerializer):
type_id = TypeId.NAMED_STRUCT
@@ -497,13 +497,13 @@ class ClassResolver:
def _create_serializer(self, cls):
for clz in cls.__mro__:
- class_info = self._classes_info.get(clz)
+ type_info = self._types_info.get(clz)
if (
- class_info
- and class_info.serializer
- and class_info.serializer.support_subclass()
+ type_info
+ and type_info.serializer
+ and type_info.serializer.support_subclass()
):
- serializer = type(class_info.serializer)(self.fory, cls)
+ serializer = type(type_info.serializer)(self.fory, cls)
break
else:
if dataclasses.is_dataclass(cls):
@@ -516,34 +516,34 @@ class ClassResolver:
serializer = PickleSerializer(self.fory, cls)
return serializer
- def _load_metabytes_to_classinfo(self, ns_metabytes, type_metabytes):
- typeinfo = self._ns_type_to_classinfo.get((ns_metabytes,
type_metabytes))
+ def _load_metabytes_to_typeinfo(self, ns_metabytes, type_metabytes):
+ typeinfo = self._ns_type_to_typeinfo.get((ns_metabytes,
type_metabytes))
if typeinfo is not None:
return typeinfo
ns = ns_metabytes.decode(self.namespace_decoder)
typename = type_metabytes.decode(self.typename_decoder)
# the hash computed between languages may be different.
- typeinfo = self._named_type_to_classinfo.get((ns, typename))
+ typeinfo = self._named_type_to_typeinfo.get((ns, typename))
if typeinfo is not None:
- self._ns_type_to_classinfo[(ns_metabytes, type_metabytes)] =
typeinfo
+ self._ns_type_to_typeinfo[(ns_metabytes, type_metabytes)] =
typeinfo
return typeinfo
cls = load_class(ns + "#" + typename)
- classinfo = self.get_classinfo(cls)
- self._ns_type_to_classinfo[(ns_metabytes, type_metabytes)] = classinfo
- return classinfo
+ typeinfo = self.get_typeinfo(cls)
+ self._ns_type_to_typeinfo[(ns_metabytes, type_metabytes)] = typeinfo
+ return typeinfo
- def write_typeinfo(self, buffer, classinfo):
- if classinfo.dynamic_type:
+ def write_typeinfo(self, buffer, typeinfo):
+ if typeinfo.dynamic_type:
return
- type_id = classinfo.type_id
+ type_id = typeinfo.type_id
internal_type_id = type_id & 0xFF
buffer.write_varuint32(type_id)
if TypeId.is_namespaced_type(internal_type_id):
self.metastring_resolver.write_meta_string_bytes(
- buffer, classinfo.namespace_bytes
+ buffer, typeinfo.namespace_bytes
)
self.metastring_resolver.write_meta_string_bytes(
- buffer, classinfo.typename_bytes
+ buffer, typeinfo.typename_bytes
)
def read_typeinfo(self, buffer):
@@ -552,23 +552,21 @@ class ClassResolver:
if TypeId.is_namespaced_type(internal_type_id):
ns_metabytes =
self.metastring_resolver.read_meta_string_bytes(buffer)
type_metabytes =
self.metastring_resolver.read_meta_string_bytes(buffer)
- typeinfo = self._ns_type_to_classinfo.get((ns_metabytes,
type_metabytes))
+ typeinfo = self._ns_type_to_typeinfo.get((ns_metabytes,
type_metabytes))
if typeinfo is None:
ns = ns_metabytes.decode(self.namespace_decoder)
typename = type_metabytes.decode(self.typename_decoder)
- typeinfo = self._named_type_to_classinfo.get((ns, typename))
+ typeinfo = self._named_type_to_typeinfo.get((ns, typename))
if typeinfo is not None:
- self._ns_type_to_classinfo[
- (ns_metabytes, type_metabytes)
- ] = typeinfo
+ self._ns_type_to_typeinfo[(ns_metabytes, type_metabytes)]
= typeinfo
return typeinfo
- # TODO(chaokunyang) generate a dynamic class and serializer
+ # TODO(chaokunyang) generate a dynamic type and serializer
# when meta share is enabled.
name = ns + "." + typename if ns else typename
raise TypeUnregisteredError(f"{name} not registered")
return typeinfo
else:
- return self._type_id_to_classinfo[type_id]
+ return self._type_id_to_typeinfo[type_id]
def reset(self):
pass
diff --git a/python/pyfory/_serialization.pyx b/python/pyfory/_serialization.pyx
index 9b39efd3..f635dcc9 100644
--- a/python/pyfory/_serialization.pyx
+++ b/python/pyfory/_serialization.pyx
@@ -31,7 +31,7 @@ from pyfory._util import get_bit, set_bit, clear_bit
from pyfory import _fory as fmod
from pyfory._fory import Language
from pyfory._fory import _PicklerStub, _UnpicklerStub, Pickler, Unpickler
-from pyfory._fory import _ENABLE_CLASS_REGISTRATION_FORCIBLY
+from pyfory._fory import _ENABLE_TYPE_REGISTRATION_FORCIBLY
from pyfory.lib import mmh3
from pyfory.meta.metastring import Encoding
from pyfory.type import is_primitive_type
@@ -219,15 +219,15 @@ cdef class MapRefResolver:
self.read_object = None
-cdef int8_t USE_CLASSNAME = 0
-cdef int8_t USE_CLASS_ID = 1
-# preserve 0 as flag for class id not set in ClassInfo`
-cdef int8_t NO_CLASS_ID = 0
+cdef int8_t USE_TYPE_NAME = 0
+cdef int8_t USE_TYPE_ID = 1
+# preserve 0 as flag for type id not set in TypeInfo`
+cdef int8_t NO_TYPE_ID = 0
cdef int8_t DEFAULT_DYNAMIC_WRITE_META_STR_ID =
fmod.DEFAULT_DYNAMIC_WRITE_META_STR_ID
-cdef int8_t INT64_CLASS_ID = fmod.INT64_CLASS_ID
-cdef int8_t FLOAT64_CLASS_ID = fmod.FLOAT64_CLASS_ID
-cdef int8_t BOOL_CLASS_ID = fmod.BOOL_CLASS_ID
-cdef int8_t STRING_CLASS_ID = fmod.STRING_CLASS_ID
+cdef int8_t INT64_TYPE_ID = fmod.INT64_TYPE_ID
+cdef int8_t FLOAT64_TYPE_ID = fmod.FLOAT64_TYPE_ID
+cdef int8_t BOOL_TYPE_ID = fmod.BOOL_TYPE_ID
+cdef int8_t STRING_TYPE_ID = fmod.STRING_TYPE_ID
cdef int16_t MAGIC_NUMBER = fmod.MAGIC_NUMBER
cdef int32_t NOT_NULL_INT64_FLAG = fmod.NOT_NULL_INT64_FLAG
@@ -373,7 +373,7 @@ cdef class MetaStringResolver:
@cython.final
-cdef class ClassInfo:
+cdef class TypeInfo:
"""
If dynamic_type is true, the serializer will be a dynamic typed serializer
and it will write type info when writing the data.
@@ -398,7 +398,7 @@ cdef class ClassInfo:
def __init__(
self,
cls: Union[type, TypeVar] = None,
- type_id: int = NO_CLASS_ID,
+ type_id: int = NO_TYPE_ID,
serializer: Serializer = None,
namespace_bytes: MetaStringBytes = None,
typename_bytes: MetaStringBytes = None,
@@ -412,33 +412,33 @@ cdef class ClassInfo:
self.dynamic_type = dynamic_type
def __repr__(self):
- return f"ClassInfo(cls={self.cls}, type_id={self.type_id}, " \
+ return f"TypeInfo(cls={self.cls}, type_id={self.type_id}, " \
f"serializer={self.serializer})"
@cython.final
-cdef class ClassResolver:
+cdef class TypeResolver:
cdef:
readonly Fory fory
readonly MetaStringResolver metastring_resolver
object _resolver
- vector[PyObject *] _c_registered_id_to_class_info
- # cls -> ClassInfo
- flat_hash_map[uint64_t, PyObject *] _c_classes_info
- # hash -> ClassInfo
- flat_hash_map[pair[int64_t, int64_t], PyObject *]
_c_meta_hash_to_classinfo
+ vector[PyObject *] _c_registered_id_to_type_info
+ # cls -> TypeInfo
+ flat_hash_map[uint64_t, PyObject *] _c_types_info
+ # hash -> TypeInfo
+ flat_hash_map[pair[int64_t, int64_t], PyObject *]
_c_meta_hash_to_typeinfo
MetaStringResolver meta_string_resolver
def __init__(self, fory):
self.fory = fory
self.metastring_resolver = fory.metastring_resolver
- from pyfory._registry import ClassResolver
- self._resolver = ClassResolver(fory)
+ from pyfory._registry import TypeResolver
+ self._resolver = TypeResolver(fory)
def initialize(self):
self._resolver.initialize()
- for classinfo in self._resolver._classes_info.values():
- self._populate_typeinfo(classinfo)
+ for typeinfo in self._resolver._types_info.values():
+ self._populate_typeinfo(typeinfo)
def register_type(
self,
@@ -460,72 +460,72 @@ cdef class ClassResolver:
cdef _populate_typeinfo(self, typeinfo):
type_id = typeinfo.type_id
- if type_id >= self._c_registered_id_to_class_info.size():
- self._c_registered_id_to_class_info.resize(type_id * 2, NULL)
+ if type_id >= self._c_registered_id_to_type_info.size():
+ self._c_registered_id_to_type_info.resize(type_id * 2, NULL)
if type_id > 0 and (self.fory.language == Language.PYTHON or not
IsNamespacedType(type_id)):
- self._c_registered_id_to_class_info[type_id] = <PyObject *>
typeinfo
- self._c_classes_info[<uintptr_t> <PyObject *> typeinfo.cls] =
<PyObject *> typeinfo
+ self._c_registered_id_to_type_info[type_id] = <PyObject *> typeinfo
+ self._c_types_info[<uintptr_t> <PyObject *> typeinfo.cls] = <PyObject
*> typeinfo
if typeinfo.typename_bytes is not None:
- self._load_bytes_to_classinfo(type_id, typeinfo.namespace_bytes,
typeinfo.typename_bytes)
+ self._load_bytes_to_typeinfo(type_id, typeinfo.namespace_bytes,
typeinfo.typename_bytes)
def register_serializer(self, cls: Union[type, TypeVar], serializer):
- classinfo1 = self._resolver.get_classinfo(cls)
+ typeinfo1 = self._resolver.get_typeinfo(cls)
self._resolver.register_serializer(cls, serializer)
- classinfo2 = self._resolver.get_classinfo(cls)
- if classinfo1.type_id != classinfo2.type_id:
- self._c_registered_id_to_class_info[classinfo1.type_id] = NULL
- self._populate_typeinfo(classinfo2)
+ typeinfo2 = self._resolver.get_typeinfo(cls)
+ if typeinfo1.type_id != typeinfo2.type_id:
+ self._c_registered_id_to_type_info[typeinfo1.type_id] = NULL
+ self._populate_typeinfo(typeinfo2)
cpdef inline Serializer get_serializer(self, cls):
"""
Returns
-------
- Returns or create serializer for the provided class
+ Returns or create serializer for the provided type
"""
- return self.get_classinfo(cls).serializer
-
- cpdef inline ClassInfo get_classinfo(self, cls, create=True):
- cdef PyObject * classinfo_ptr = self._c_classes_info[<uintptr_t>
<PyObject *> cls]
- cdef ClassInfo class_info
- if classinfo_ptr != NULL:
- class_info = <object> classinfo_ptr
- if class_info.serializer is not None:
- return class_info
+ return self.get_typeinfo(cls).serializer
+
+ cpdef inline TypeInfo get_typeinfo(self, cls, create=True):
+ cdef PyObject * typeinfo_ptr = self._c_types_info[<uintptr_t>
<PyObject *> cls]
+ cdef TypeInfo type_info
+ if typeinfo_ptr != NULL:
+ type_info = <object> typeinfo_ptr
+ if type_info.serializer is not None:
+ return type_info
else:
- class_info.serializer = self._resolver._create_serializer(cls)
- return class_info
+ type_info.serializer = self._resolver._create_serializer(cls)
+ return type_info
elif not create:
return None
else:
- class_info = self._resolver.get_classinfo(cls, create=create)
- self._c_classes_info[<uintptr_t> <PyObject *> cls] = <PyObject *>
class_info
- self._populate_typeinfo(class_info)
- return class_info
+ type_info = self._resolver.get_typeinfo(cls, create=create)
+ self._c_types_info[<uintptr_t> <PyObject *> cls] = <PyObject *>
type_info
+ self._populate_typeinfo(type_info)
+ return type_info
- cdef inline ClassInfo _load_bytes_to_classinfo(
+ cdef inline TypeInfo _load_bytes_to_typeinfo(
self, int32_t type_id, MetaStringBytes ns_metabytes,
MetaStringBytes type_metabytes):
- cdef PyObject * classinfo_ptr = self._c_meta_hash_to_classinfo[
+ cdef PyObject * typeinfo_ptr = self._c_meta_hash_to_typeinfo[
pair[int64_t, int64_t](ns_metabytes.hashcode,
type_metabytes.hashcode)]
- if classinfo_ptr != NULL:
- return <ClassInfo> classinfo_ptr
- classinfo = self._resolver._load_metabytes_to_classinfo(ns_metabytes,
type_metabytes)
- classinfo_ptr = <PyObject *> classinfo
- self._c_meta_hash_to_classinfo[pair[int64_t, int64_t](
- ns_metabytes.hashcode, type_metabytes.hashcode)] = classinfo_ptr
- return classinfo
-
- cpdef write_typeinfo(self, Buffer buffer, ClassInfo classinfo):
- if classinfo.dynamic_type:
+ if typeinfo_ptr != NULL:
+ return <TypeInfo> typeinfo_ptr
+ typeinfo = self._resolver._load_metabytes_to_typeinfo(ns_metabytes,
type_metabytes)
+ typeinfo_ptr = <PyObject *> typeinfo
+ self._c_meta_hash_to_typeinfo[pair[int64_t, int64_t](
+ ns_metabytes.hashcode, type_metabytes.hashcode)] = typeinfo_ptr
+ return typeinfo
+
+ cpdef write_typeinfo(self, Buffer buffer, TypeInfo typeinfo):
+ if typeinfo.dynamic_type:
return
cdef:
- int32_t type_id = classinfo.type_id
+ int32_t type_id = typeinfo.type_id
int32_t internal_type_id = type_id & 0xFF
buffer.write_varuint32(type_id)
if IsNamespacedType(internal_type_id):
- self.metastring_resolver.write_meta_string_bytes(buffer,
classinfo.namespace_bytes)
- self.metastring_resolver.write_meta_string_bytes(buffer,
classinfo.typename_bytes)
+ self.metastring_resolver.write_meta_string_bytes(buffer,
typeinfo.namespace_bytes)
+ self.metastring_resolver.write_meta_string_bytes(buffer,
typeinfo.typename_bytes)
- cpdef inline ClassInfo read_typeinfo(self, Buffer buffer):
+ cpdef inline TypeInfo read_typeinfo(self, Buffer buffer):
cdef:
int32_t type_id = buffer.read_varuint32()
int32_t internal_type_id = type_id & 0xFF
@@ -533,14 +533,14 @@ cdef class ClassResolver:
if IsNamespacedType(internal_type_id):
namespace_bytes =
self.metastring_resolver.read_meta_string_bytes(buffer)
typename_bytes =
self.metastring_resolver.read_meta_string_bytes(buffer)
- return self._load_bytes_to_classinfo(type_id, namespace_bytes,
typename_bytes)
- if type_id < 0 or type_id > self._c_registered_id_to_class_info.size():
+ return self._load_bytes_to_typeinfo(type_id, namespace_bytes,
typename_bytes)
+ if type_id < 0 or type_id > self._c_registered_id_to_type_info.size():
raise ValueError(f"Unexpected type_id {type_id}")
- classinfo_ptr = self._c_registered_id_to_class_info[type_id]
- if classinfo_ptr == NULL:
+ typeinfo_ptr = self._c_registered_id_to_type_info[type_id]
+ if typeinfo_ptr == NULL:
raise ValueError(f"Unexpected type_id {type_id}")
- classinfo = <ClassInfo> classinfo_ptr
- return classinfo
+ typeinfo = <TypeInfo> typeinfo_ptr
+ return typeinfo
cpdef inline reset(self):
pass
@@ -556,10 +556,10 @@ cdef class ClassResolver:
cdef class Fory:
cdef readonly object language
cdef readonly c_bool ref_tracking
- cdef readonly c_bool require_class_registration
+ cdef readonly c_bool require_type_registration
cdef readonly c_bool is_py
cdef readonly MapRefResolver ref_resolver
- cdef readonly ClassResolver class_resolver
+ cdef readonly TypeResolver type_resolver
cdef readonly MetaStringResolver metastring_resolver
cdef readonly SerializationContext serialization_context
cdef Buffer buffer
@@ -575,34 +575,34 @@ cdef class Fory:
self,
language=Language.XLANG,
ref_tracking: bool = False,
- require_class_registration: bool = True,
+ require_type_registration: bool = True,
):
"""
- :param require_class_registration:
- Whether to require registering classes for serialization, enabled by
default.
- If disabled, unknown insecure classes can be deserialized, which can
be
- insecure and cause remote code execution attack if the classes
+ :param require_type_registration:
+ 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 class registration if you can't ensure your
environment are
+ Do not disable type registration if you can't ensure your environment
are
*indeed secure*. We are not responsible for security risks if
you disable this option.
"""
self.language = language
- if _ENABLE_CLASS_REGISTRATION_FORCIBLY or require_class_registration:
- self.require_class_registration = True
+ if _ENABLE_TYPE_REGISTRATION_FORCIBLY or require_type_registration:
+ self.require_type_registration = True
else:
- self.require_class_registration = False
+ self.require_type_registration = False
self.ref_tracking = ref_tracking
self.ref_resolver = MapRefResolver(ref_tracking)
self.is_py = self.language == Language.PYTHON
self.metastring_resolver = MetaStringResolver()
- self.class_resolver = ClassResolver(self)
- self.class_resolver.initialize()
+ self.type_resolver = TypeResolver(self)
+ self.type_resolver.initialize()
self.serialization_context = SerializationContext()
self.buffer = Buffer.allocate(32)
- if not require_class_registration:
+ if not require_type_registration:
warnings.warn(
- "Class registration is disabled, unknown classes can be
deserialized "
+ "Type registration is disabled, unknown types can be
deserialized "
"which may be insecure.",
RuntimeWarning,
stacklevel=2,
@@ -619,7 +619,7 @@ cdef class Fory:
self._peer_language = None
def register_serializer(self, cls: Union[type, TypeVar], Serializer
serializer):
- self.class_resolver.register_serializer(cls, serializer)
+ self.type_resolver.register_serializer(cls, serializer)
def register_type(
self,
@@ -630,7 +630,7 @@ cdef class Fory:
typename: str = None,
serializer=None,
):
- self.class_resolver.register_type(
+ self.type_resolver.register_type(
cls, type_id=type_id, namespace=namespace, typename=typename,
serializer=serializer)
def serialize(
@@ -696,7 +696,7 @@ cdef class Fory:
return buffer.to_bytes(0, buffer.writer_index)
cpdef inline serialize_ref(
- self, Buffer buffer, obj, ClassInfo classinfo=None):
+ self, Buffer buffer, obj, TypeInfo typeinfo=None):
cls = type(obj)
if cls is str:
buffer.write_int16(NOT_NULL_STRING_FLAG)
@@ -716,32 +716,32 @@ cdef class Fory:
return
if self.ref_resolver.write_ref_or_null(buffer, obj):
return
- if classinfo is None:
- classinfo = self.class_resolver.get_classinfo(cls)
- self.class_resolver.write_typeinfo(buffer, classinfo)
- classinfo.serializer.write(buffer, obj)
+ if typeinfo is None:
+ typeinfo = self.type_resolver.get_typeinfo(cls)
+ self.type_resolver.write_typeinfo(buffer, typeinfo)
+ typeinfo.serializer.write(buffer, obj)
cpdef inline serialize_nonref(self, Buffer buffer, obj):
cls = type(obj)
if cls is str:
- buffer.write_varuint32(STRING_CLASS_ID)
+ buffer.write_varuint32(STRING_TYPE_ID)
buffer.write_string(obj)
return
elif cls is int:
- buffer.write_varuint32(INT64_CLASS_ID)
+ buffer.write_varuint32(INT64_TYPE_ID)
buffer.write_varint64(obj)
return
elif cls is bool:
- buffer.write_varuint32(BOOL_CLASS_ID)
+ buffer.write_varuint32(BOOL_TYPE_ID)
buffer.write_bool(obj)
return
elif cls is float:
- buffer.write_varuint32(FLOAT64_CLASS_ID)
+ buffer.write_varuint32(FLOAT64_TYPE_ID)
buffer.write_double(obj)
return
- cdef ClassInfo classinfo = self.class_resolver.get_classinfo(cls)
- self.class_resolver.write_typeinfo(buffer, classinfo)
- classinfo.serializer.write(buffer, obj)
+ cdef TypeInfo typeinfo = self.type_resolver.get_typeinfo(cls)
+ self.type_resolver.write_typeinfo(buffer, typeinfo)
+ typeinfo.serializer.write(buffer, obj)
cpdef inline xserialize_ref(
self, Buffer buffer, obj, Serializer serializer=None):
@@ -762,9 +762,9 @@ cdef class Fory:
cpdef inline xserialize_nonref(
self, Buffer buffer, obj, Serializer serializer=None):
if serializer is None:
- classinfo = self.class_resolver.get_classinfo(type(obj))
- self.class_resolver.write_typeinfo(buffer, classinfo)
- serializer = classinfo.serializer
+ typeinfo = self.type_resolver.get_typeinfo(type(obj))
+ self.type_resolver.write_typeinfo(buffer, typeinfo)
+ serializer = typeinfo.serializer
serializer.xwrite(buffer, obj)
def deserialize(
@@ -782,7 +782,7 @@ cdef class Fory:
cpdef inline _deserialize(
self, Buffer buffer, buffers=None, unsupported_objects=None):
- if not self.require_class_registration:
+ if not self.require_type_registration:
self.unpickler = Unpickler(buffer)
if unsupported_objects is not None:
self._unsupported_objects = iter(unsupported_objects)
@@ -830,8 +830,8 @@ cdef class Fory:
if ref_id < NOT_NULL_VALUE_FLAG:
return ref_resolver.get_read_object()
# indicates that the object is first read.
- cdef ClassInfo classinfo = self.class_resolver.read_typeinfo(buffer)
- cls = classinfo.cls
+ cdef TypeInfo typeinfo = self.type_resolver.read_typeinfo(buffer)
+ cls = typeinfo.cls
if cls is str:
return buffer.read_string()
elif cls is int:
@@ -840,14 +840,14 @@ cdef class Fory:
return buffer.read_bool()
elif cls is float:
return buffer.read_double()
- o = classinfo.serializer.read(buffer)
+ o = typeinfo.serializer.read(buffer)
ref_resolver.set_read_object(ref_id, o)
return o
cpdef inline deserialize_nonref(self, Buffer buffer):
"""Deserialize not-null and non-reference object from buffer."""
- cdef ClassInfo classinfo = self.class_resolver.read_typeinfo(buffer)
- cls = classinfo.cls
+ cdef TypeInfo typeinfo = self.type_resolver.read_typeinfo(buffer)
+ cls = typeinfo.cls
if cls is str:
return buffer.read_string()
elif cls is int:
@@ -856,7 +856,7 @@ cdef class Fory:
return buffer.read_bool()
elif cls is float:
return buffer.read_double()
- return classinfo.serializer.read(buffer)
+ return typeinfo.serializer.read(buffer)
cpdef inline xdeserialize_ref(self, Buffer buffer, Serializer
serializer=None):
cdef MapRefResolver ref_resolver
@@ -883,7 +883,7 @@ cdef class Fory:
cpdef inline xdeserialize_nonref(
self, Buffer buffer, Serializer serializer=None):
if serializer is None:
- serializer = self.class_resolver.read_typeinfo(buffer).serializer
+ serializer = self.type_resolver.read_typeinfo(buffer).serializer
return serializer.xread(buffer)
cpdef inline write_buffer_object(self, Buffer buffer, buffer_object):
@@ -928,13 +928,13 @@ cdef class Fory:
return next(self._unsupported_objects)
cpdef inline write_ref_pyobject(
- self, Buffer buffer, value, ClassInfo classinfo=None):
+ self, Buffer buffer, value, TypeInfo typeinfo=None):
if self.ref_resolver.write_ref_or_null(buffer, value):
return
- if classinfo is None:
- classinfo = self.class_resolver.get_classinfo(type(value))
- self.class_resolver.write_typeinfo(buffer, classinfo)
- classinfo.serializer.write(buffer, value)
+ if typeinfo is None:
+ typeinfo = self.type_resolver.get_typeinfo(type(value))
+ self.type_resolver.write_typeinfo(buffer, typeinfo)
+ typeinfo.serializer.write(buffer, value)
cpdef inline read_ref_pyobject(self, Buffer buffer):
cdef MapRefResolver ref_resolver = self.ref_resolver
@@ -942,14 +942,14 @@ cdef class Fory:
if ref_id < NOT_NULL_VALUE_FLAG:
return ref_resolver.get_read_object()
# indicates that the object is first read.
- cdef ClassInfo classinfo = self.class_resolver.read_typeinfo(buffer)
- o = classinfo.serializer.read(buffer)
+ cdef TypeInfo typeinfo = self.type_resolver.read_typeinfo(buffer)
+ o = typeinfo.serializer.read(buffer)
ref_resolver.set_read_object(ref_id, o)
return o
cpdef inline reset_write(self):
self.ref_resolver.reset_write()
- self.class_resolver.reset_write()
+ self.type_resolver.reset_write()
self.metastring_resolver.reset_write()
self.serialization_context.reset()
self.pickler.clear_memo()
@@ -957,7 +957,7 @@ cdef class Fory:
cpdef inline reset_read(self):
self.ref_resolver.reset_read()
- self.class_resolver.reset_read()
+ self.type_resolver.reset_read()
self.metastring_resolver.reset_read()
self.serialization_context.reset()
self._buffers = None
@@ -1234,33 +1234,33 @@ cdef int8_t COLLECTION_NOT_SAME_TYPE = 0b1000
cdef class CollectionSerializer(Serializer):
- cdef ClassResolver class_resolver
+ cdef TypeResolver type_resolver
cdef MapRefResolver ref_resolver
cdef Serializer elem_serializer
cdef c_bool is_py
cdef int8_t elem_tracking_ref
cdef elem_type
- cdef ClassInfo elem_typeinfo
+ cdef TypeInfo elem_typeinfo
def __init__(self, fory, type_, elem_serializer=None):
super().__init__(fory, type_)
- self.class_resolver = fory.class_resolver
+ self.type_resolver = fory.type_resolver
self.ref_resolver = fory.ref_resolver
self.elem_serializer = elem_serializer
if elem_serializer is None:
self.elem_type = None
- self.elem_typeinfo = self.class_resolver.get_classinfo(None)
+ self.elem_typeinfo = self.type_resolver.get_typeinfo(None)
self.elem_tracking_ref = -1
else:
self.elem_type = elem_serializer.type_
- self.elem_typeinfo =
fory.class_resolver.get_classinfo(self.elem_type)
+ self.elem_typeinfo =
fory.type_resolver.get_typeinfo(self.elem_type)
self.elem_tracking_ref = <int8_t>
(elem_serializer.need_to_write_ref)
self.is_py = fory.is_py
cdef pair[int8_t, int64_t] write_header(self, Buffer buffer, value):
cdef int8_t collect_flag = COLLECTION_DEFAULT_FLAG
elem_type = self.elem_type
- cdef ClassInfo elem_typeinfo = self.elem_typeinfo
+ cdef TypeInfo elem_typeinfo = self.elem_typeinfo
cdef c_bool has_null = False
cdef c_bool has_different_type = False
if elem_type is None:
@@ -1275,7 +1275,7 @@ cdef class CollectionSerializer(Serializer):
collect_flag |= COLLECTION_NOT_SAME_TYPE
has_different_type = True
if not has_different_type:
- elem_typeinfo = self.class_resolver.get_classinfo(elem_type)
+ elem_typeinfo = self.type_resolver.get_typeinfo(elem_type)
else:
for s in value:
if s is None:
@@ -1293,7 +1293,7 @@ cdef class CollectionSerializer(Serializer):
buffer.write_int8(collect_flag)
if (not has_different_type and
collect_flag & COLLECTION_NOT_DECL_ELEMENT_TYPE != 0):
- self.class_resolver.write_typeinfo(buffer, elem_typeinfo)
+ self.type_resolver.write_typeinfo(buffer, elem_typeinfo)
return pair[int8_t, int64_t](collect_flag, obj2int(elem_typeinfo))
cpdef write(self, Buffer buffer, value):
@@ -1303,10 +1303,10 @@ cdef class CollectionSerializer(Serializer):
cdef pair[int8_t, int64_t] header_pair = self.write_header(buffer,
value)
cdef int8_t collect_flag = header_pair.first
cdef int64_t elem_typeinfo_ptr = header_pair.second
- cdef ClassInfo elem_typeinfo = <type> int2obj(elem_typeinfo_ptr)
+ cdef TypeInfo elem_typeinfo = <type> int2obj(elem_typeinfo_ptr)
cdef elem_type = elem_typeinfo.cls
cdef MapRefResolver ref_resolver = self.ref_resolver
- cdef ClassResolver class_resolver = self.class_resolver
+ cdef TypeResolver type_resolver = self.type_resolver
cdef c_bool is_py = self.is_py
cdef serializer = type(elem_typeinfo.serializer)
if (collect_flag & COLLECTION_NOT_SAME_TYPE) == 0:
@@ -1340,12 +1340,12 @@ cdef class CollectionSerializer(Serializer):
buffer.write_double(s)
else:
if not ref_resolver.write_ref_or_null(buffer, s):
- classinfo = class_resolver.get_classinfo(cls)
- class_resolver.write_typeinfo(buffer, classinfo)
+ typeinfo = type_resolver.get_typeinfo(cls)
+ type_resolver.write_typeinfo(buffer, typeinfo)
if is_py:
- classinfo.serializer.write(buffer, s)
+ typeinfo.serializer.write(buffer, s)
else:
- classinfo.serializer.xwrite(buffer, s)
+ typeinfo.serializer.xwrite(buffer, s)
cdef inline _write_string(self, Buffer buffer, value):
for s in value:
@@ -1393,43 +1393,43 @@ cdef class CollectionSerializer(Serializer):
for i in range(len_):
self._add_element(collection_, i, buffer.read_double())
- cpdef _write_same_type_no_ref(self, Buffer buffer, value, ClassInfo
classinfo):
+ cpdef _write_same_type_no_ref(self, Buffer buffer, value, TypeInfo
typeinfo):
cdef MapRefResolver ref_resolver = self.ref_resolver
- cdef ClassResolver class_resolver = self.class_resolver
+ cdef TypeResolver type_resolver = self.type_resolver
if self.is_py:
for s in value:
- classinfo.serializer.write(buffer, s)
+ typeinfo.serializer.write(buffer, s)
else:
for s in value:
- classinfo.serializer.xwrite(buffer, s)
+ typeinfo.serializer.xwrite(buffer, s)
- cpdef _read_same_type_no_ref(self, Buffer buffer, int64_t len_, object
collection_, ClassInfo classinfo):
+ cpdef _read_same_type_no_ref(self, Buffer buffer, int64_t len_, object
collection_, TypeInfo typeinfo):
cdef MapRefResolver ref_resolver = self.ref_resolver
- cdef ClassResolver class_resolver = self.class_resolver
+ cdef TypeResolver type_resolver = self.type_resolver
if self.is_py:
for i in range(len_):
- obj = classinfo.serializer.read(buffer)
+ obj = typeinfo.serializer.read(buffer)
self._add_element(collection_, i, obj)
else:
for i in range(len_):
- obj = classinfo.serializer.xread(buffer)
+ obj = typeinfo.serializer.xread(buffer)
self._add_element(collection_, i, obj)
- cpdef _write_same_type_ref(self, Buffer buffer, value, ClassInfo
classinfo):
+ cpdef _write_same_type_ref(self, Buffer buffer, value, TypeInfo typeinfo):
cdef MapRefResolver ref_resolver = self.ref_resolver
- cdef ClassResolver class_resolver = self.class_resolver
+ cdef TypeResolver type_resolver = self.type_resolver
if self.is_py:
for s in value:
if not ref_resolver.write_ref_or_null(buffer, s):
- classinfo.serializer.write(buffer, s)
+ typeinfo.serializer.write(buffer, s)
else:
for s in value:
if not ref_resolver.write_ref_or_null(buffer, s):
- classinfo.serializer.xwrite(buffer, s)
+ typeinfo.serializer.xwrite(buffer, s)
- cpdef _read_same_type_ref(self, Buffer buffer, int64_t len_, object
collection_, ClassInfo classinfo):
+ cpdef _read_same_type_ref(self, Buffer buffer, int64_t len_, object
collection_, TypeInfo typeinfo):
cdef MapRefResolver ref_resolver = self.ref_resolver
- cdef ClassResolver class_resolver = self.class_resolver
+ cdef TypeResolver type_resolver = self.type_resolver
cdef c_bool is_py = self.is_py
for i in range(len_):
ref_id = ref_resolver.try_preserve_ref_id(buffer)
@@ -1437,9 +1437,9 @@ cdef class CollectionSerializer(Serializer):
obj = ref_resolver.get_read_object()
else:
if is_py:
- obj = classinfo.serializer.read(buffer)
+ obj = typeinfo.serializer.read(buffer)
else:
- obj = classinfo.serializer.xread(buffer)
+ obj = typeinfo.serializer.xread(buffer)
ref_resolver.set_read_object(ref_id, obj)
self._add_element(collection_, i, obj)
@@ -1452,7 +1452,7 @@ cdef class CollectionSerializer(Serializer):
cdef class ListSerializer(CollectionSerializer):
cpdef read(self, Buffer buffer):
cdef MapRefResolver ref_resolver = self.fory.ref_resolver
- cdef ClassResolver class_resolver = self.fory.class_resolver
+ cdef TypeResolver type_resolver = self.fory.type_resolver
cdef int32_t len_ = buffer.read_varuint32()
cdef list list_ = PyList_New(len_)
if len_ == 0:
@@ -1460,15 +1460,15 @@ cdef class ListSerializer(CollectionSerializer):
cdef int8_t collect_flag = buffer.read_int8()
ref_resolver.reference(list_)
cdef c_bool is_py = self.is_py
- cdef ClassInfo classinfo
+ cdef TypeInfo typeinfo
cdef int32_t type_id = -1
if (collect_flag & COLLECTION_NOT_SAME_TYPE) == 0:
if collect_flag & COLLECTION_NOT_DECL_ELEMENT_TYPE != 0:
- classinfo = self.class_resolver.read_typeinfo(buffer)
+ typeinfo = self.type_resolver.read_typeinfo(buffer)
else:
- classinfo = self.elem_typeinfo
+ typeinfo = self.elem_typeinfo
if (collect_flag & COLLECTION_HAS_NULL) == 0:
- type_id = classinfo.type_id
+ type_id = typeinfo.type_id
if type_id == <int32_t>TypeId.STRING:
self._read_string(buffer, len_, list_)
return list_
@@ -1482,12 +1482,12 @@ cdef class ListSerializer(CollectionSerializer):
self._read_float(buffer, len_, list_)
return list_
if (collect_flag & COLLECTION_TRACKING_REF) == 0:
- self._read_same_type_no_ref(buffer, len_, list_, classinfo)
+ self._read_same_type_no_ref(buffer, len_, list_, typeinfo)
else:
- self._read_same_type_ref(buffer, len_, list_, classinfo)
+ self._read_same_type_ref(buffer, len_, list_, typeinfo)
else:
for i in range(len_):
- elem = get_next_element(buffer, ref_resolver, class_resolver,
is_py)
+ elem = get_next_element(buffer, ref_resolver, type_resolver,
is_py)
Py_INCREF(elem)
PyList_SET_ITEM(list_, i, elem)
return list_
@@ -1502,17 +1502,17 @@ cdef class ListSerializer(CollectionSerializer):
cdef inline get_next_element(
Buffer buffer,
MapRefResolver ref_resolver,
- ClassResolver class_resolver,
+ TypeResolver type_resolver,
c_bool is_py,
):
cdef int32_t ref_id
- cdef ClassInfo classinfo
+ cdef TypeInfo typeinfo
ref_id = ref_resolver.try_preserve_ref_id(buffer)
if ref_id < NOT_NULL_VALUE_FLAG:
return ref_resolver.get_read_object()
# indicates that the object is first read.
- classinfo = class_resolver.read_typeinfo(buffer)
- cdef int32_t type_id = classinfo.type_id
+ typeinfo = type_resolver.read_typeinfo(buffer)
+ cdef int32_t type_id = typeinfo.type_id
# Note that all read operations in fast paths of
list/tuple/set/dict/sub_dict
# ust match corresponding writing operations. Otherwise, ref tracking will
# error.
@@ -1526,9 +1526,9 @@ cdef inline get_next_element(
return buffer.read_double()
else:
if is_py:
- o = classinfo.serializer.read(buffer)
+ o = typeinfo.serializer.read(buffer)
else:
- o = classinfo.serializer.xread(buffer)
+ o = typeinfo.serializer.xread(buffer)
ref_resolver.set_read_object(ref_id, o)
return o
@@ -1537,22 +1537,22 @@ cdef inline get_next_element(
cdef class TupleSerializer(CollectionSerializer):
cpdef inline read(self, Buffer buffer):
cdef MapRefResolver ref_resolver = self.fory.ref_resolver
- cdef ClassResolver class_resolver = self.fory.class_resolver
+ cdef TypeResolver type_resolver = self.fory.type_resolver
cdef int32_t len_ = buffer.read_varuint32()
cdef tuple tuple_ = PyTuple_New(len_)
if len_ == 0:
return tuple_
cdef int8_t collect_flag = buffer.read_int8()
cdef c_bool is_py = self.is_py
- cdef ClassInfo classinfo
+ cdef TypeInfo typeinfo
cdef int32_t type_id = -1
if (collect_flag & COLLECTION_NOT_SAME_TYPE) == 0:
if collect_flag & COLLECTION_NOT_DECL_ELEMENT_TYPE != 0:
- classinfo = self.class_resolver.read_typeinfo(buffer)
+ typeinfo = self.type_resolver.read_typeinfo(buffer)
else:
- classinfo = self.elem_typeinfo
+ typeinfo = self.elem_typeinfo
if (collect_flag & COLLECTION_HAS_NULL) == 0:
- type_id = classinfo.type_id
+ type_id = typeinfo.type_id
if type_id == <int32_t>TypeId.STRING:
self._read_string(buffer, len_, tuple_)
return tuple_
@@ -1566,12 +1566,12 @@ cdef class TupleSerializer(CollectionSerializer):
self._read_float(buffer, len_, tuple_)
return tuple_
if (collect_flag & COLLECTION_TRACKING_REF) == 0:
- self._read_same_type_no_ref(buffer, len_, tuple_, classinfo)
+ self._read_same_type_no_ref(buffer, len_, tuple_, typeinfo)
else:
- self._read_same_type_ref(buffer, len_, tuple_, classinfo)
+ self._read_same_type_ref(buffer, len_, tuple_, typeinfo)
else:
for i in range(len_):
- elem = get_next_element(buffer, ref_resolver, class_resolver,
is_py)
+ elem = get_next_element(buffer, ref_resolver, type_resolver,
is_py)
Py_INCREF(elem)
PyTuple_SET_ITEM(tuple_, i, elem)
return tuple_
@@ -1594,7 +1594,7 @@ cdef class StringArraySerializer(ListSerializer):
cdef class SetSerializer(CollectionSerializer):
cpdef inline read(self, Buffer buffer):
cdef MapRefResolver ref_resolver = self.fory.ref_resolver
- cdef ClassResolver class_resolver = self.fory.class_resolver
+ cdef TypeResolver type_resolver = self.fory.type_resolver
cdef set instance = set()
ref_resolver.reference(instance)
cdef int32_t len_ = buffer.read_varuint32()
@@ -1602,16 +1602,16 @@ cdef class SetSerializer(CollectionSerializer):
return instance
cdef int8_t collect_flag = buffer.read_int8()
cdef int32_t ref_id
- cdef ClassInfo classinfo
+ cdef TypeInfo typeinfo
cdef int32_t type_id = -1
cdef c_bool is_py = self.is_py
if (collect_flag & COLLECTION_NOT_SAME_TYPE) == 0:
if collect_flag & COLLECTION_NOT_DECL_ELEMENT_TYPE != 0:
- classinfo = self.class_resolver.read_typeinfo(buffer)
+ typeinfo = self.type_resolver.read_typeinfo(buffer)
else:
- classinfo = self.elem_typeinfo
+ typeinfo = self.elem_typeinfo
if (collect_flag & COLLECTION_HAS_NULL) == 0:
- type_id = classinfo.type_id
+ type_id = typeinfo.type_id
if type_id == <int32_t>TypeId.STRING:
self._read_string(buffer, len_, instance)
return instance
@@ -1625,9 +1625,9 @@ cdef class SetSerializer(CollectionSerializer):
self._read_float(buffer, len_, instance)
return instance
if (collect_flag & COLLECTION_TRACKING_REF) == 0:
- self._read_same_type_no_ref(buffer, len_, instance, classinfo)
+ self._read_same_type_no_ref(buffer, len_, instance, typeinfo)
else:
- self._read_same_type_ref(buffer, len_, instance, classinfo)
+ self._read_same_type_ref(buffer, len_, instance, typeinfo)
else:
for i in range(len_):
ref_id = ref_resolver.try_preserve_ref_id(buffer)
@@ -1635,8 +1635,8 @@ cdef class SetSerializer(CollectionSerializer):
instance.add(ref_resolver.get_read_object())
continue
# indicates that the object is first read.
- classinfo = class_resolver.read_typeinfo(buffer)
- type_id = classinfo.type_id
+ typeinfo = type_resolver.read_typeinfo(buffer)
+ type_id = typeinfo.type_id
if type_id == <int32_t>TypeId.STRING:
instance.add(buffer.read_string())
elif type_id == <int32_t>TypeId.VAR_INT64:
@@ -1647,9 +1647,9 @@ cdef class SetSerializer(CollectionSerializer):
instance.add(buffer.read_double())
else:
if is_py:
- o = classinfo.serializer.read(buffer)
+ o = typeinfo.serializer.read(buffer)
else:
- o = classinfo.serializer.xread(buffer)
+ o = typeinfo.serializer.xread(buffer)
ref_resolver.set_read_object(ref_id, o)
instance.add(o)
return instance
@@ -1690,7 +1690,7 @@ cdef int32_t NULL_VALUE_KEY_DECL_TYPE_TRACKING_REF =
VALUE_HAS_NULL | KEY_DECL_T
@cython.final
cdef class MapSerializer(Serializer):
- cdef ClassResolver class_resolver
+ cdef TypeResolver type_resolver
cdef MapRefResolver ref_resolver
cdef Serializer key_serializer
cdef Serializer value_serializer
@@ -1698,7 +1698,7 @@ cdef class MapSerializer(Serializer):
def __init__(self, fory, type_, key_serializer=None,
value_serializer=None):
super().__init__(fory, type_)
- self.class_resolver = fory.class_resolver
+ self.type_resolver = fory.type_resolver
self.ref_resolver = fory.ref_resolver
self.key_serializer = key_serializer
self.value_serializer = value_serializer
@@ -1713,12 +1713,12 @@ cdef class MapSerializer(Serializer):
cdef int64_t key_addr, value_addr
cdef Py_ssize_t pos = 0
cdef Fory fory = self.fory
- cdef ClassResolver class_resolver = fory.class_resolver
+ cdef TypeResolver type_resolver = fory.type_resolver
cdef MapRefResolver ref_resolver = fory.ref_resolver
cdef Serializer key_serializer = self.key_serializer
cdef Serializer value_serializer = self.value_serializer
cdef type key_cls, value_cls, key_serializer_type,
value_serializer_type
- cdef ClassInfo key_classinfo, value_classinfo
+ cdef TypeInfo key_typeinfo, value_typeinfo
cdef int32_t chunk_size_offset, chunk_header, chunk_size
cdef c_bool key_write_ref, value_write_ref
cdef int has_next = PyDict_Next(obj, &pos, <PyObject **>&key_addr,
<PyObject **>&value_addr)
@@ -1796,15 +1796,15 @@ cdef class MapSerializer(Serializer):
if key_serializer is not None:
chunk_header |= KEY_DECL_TYPE
else:
- key_classinfo = self.class_resolver.get_classinfo(key_cls)
- class_resolver.write_typeinfo(buffer, key_classinfo)
- key_serializer = key_classinfo.serializer
+ key_typeinfo = self.type_resolver.get_typeinfo(key_cls)
+ type_resolver.write_typeinfo(buffer, key_typeinfo)
+ key_serializer = key_typeinfo.serializer
if value_serializer is not None:
chunk_header |= VALUE_DECL_TYPE
else:
- value_classinfo = self.class_resolver.get_classinfo(value_cls)
- class_resolver.write_typeinfo(buffer, value_classinfo)
- value_serializer = value_classinfo.serializer
+ value_typeinfo = self.type_resolver.get_typeinfo(value_cls)
+ type_resolver.write_typeinfo(buffer, value_typeinfo)
+ value_serializer = value_typeinfo.serializer
key_write_ref = key_serializer.need_to_write_ref
value_write_ref = value_serializer.need_to_write_ref
if key_write_ref:
@@ -1870,12 +1870,12 @@ cdef class MapSerializer(Serializer):
cpdef inline read(self, Buffer buffer):
cdef Fory fory = self.fory
cdef MapRefResolver ref_resolver = self.ref_resolver
- cdef ClassResolver class_resolver = self.class_resolver
+ cdef TypeResolver type_resolver = self.type_resolver
cdef int32_t size = buffer.read_varuint32()
cdef dict map_ = _PyDict_NewPresized(size)
ref_resolver.reference(map_)
cdef int32_t ref_id
- cdef ClassInfo key_classinfo, value_classinfo
+ cdef TypeInfo key_typeinfo, value_typeinfo
cdef int32_t chunk_header = 0
if size != 0:
chunk_header = buffer.read_uint8()
@@ -1950,9 +1950,9 @@ cdef class MapSerializer(Serializer):
value_is_declared_type = (chunk_header & VALUE_DECL_TYPE) != 0
chunk_size = buffer.read_uint8()
if not key_is_declared_type:
- key_serializer =
class_resolver.read_typeinfo(buffer).serializer
+ key_serializer = type_resolver.read_typeinfo(buffer).serializer
if not value_is_declared_type:
- value_serializer =
class_resolver.read_typeinfo(buffer).serializer
+ value_serializer =
type_resolver.read_typeinfo(buffer).serializer
key_serializer_type = type(key_serializer)
value_serializer_type = type(value_serializer)
for i in range(chunk_size):
@@ -2025,22 +2025,22 @@ cdef class MapSerializer(Serializer):
@cython.final
cdef class SubMapSerializer(Serializer):
- cdef ClassResolver class_resolver
+ cdef TypeResolver type_resolver
cdef MapRefResolver ref_resolver
cdef Serializer key_serializer
cdef Serializer value_serializer
def __init__(self, fory, type_, key_serializer=None,
value_serializer=None):
super().__init__(fory, type_)
- self.class_resolver = fory.class_resolver
+ self.type_resolver = fory.type_resolver
self.ref_resolver = fory.ref_resolver
self.key_serializer = key_serializer
self.value_serializer = value_serializer
cpdef inline write(self, Buffer buffer, value):
buffer.write_varuint32(len(value))
- cdef ClassInfo key_classinfo
- cdef ClassInfo value_classinfo
+ cdef TypeInfo key_typeinfo
+ cdef TypeInfo value_typeinfo
for k, v in value.items():
key_cls = type(k)
if key_cls is str:
@@ -2048,9 +2048,9 @@ cdef class SubMapSerializer(Serializer):
buffer.write_string(k)
else:
if not self.ref_resolver.write_ref_or_null(buffer, k):
- key_classinfo = self.class_resolver.get_classinfo(key_cls)
- self.class_resolver.write_typeinfo(buffer, key_classinfo)
- key_classinfo.serializer.write(buffer, k)
+ key_typeinfo = self.type_resolver.get_typeinfo(key_cls)
+ self.type_resolver.write_typeinfo(buffer, key_typeinfo)
+ key_typeinfo.serializer.write(buffer, k)
value_cls = type(v)
if value_cls is str:
buffer.write_int16(NOT_NULL_STRING_FLAG)
@@ -2066,37 +2066,37 @@ cdef class SubMapSerializer(Serializer):
buffer.write_double(v)
else:
if not self.ref_resolver.write_ref_or_null(buffer, v):
- value_classinfo = self.class_resolver. \
- get_classinfo(value_cls)
- self.class_resolver.write_typeinfo(buffer, value_classinfo)
- value_classinfo.serializer.write(buffer, v)
+ value_typeinfo = self.type_resolver. \
+ get_typeinfo(value_cls)
+ self.type_resolver.write_typeinfo(buffer, value_typeinfo)
+ value_typeinfo.serializer.write(buffer, v)
cpdef inline read(self, Buffer buffer):
cdef MapRefResolver ref_resolver = self.fory.ref_resolver
- cdef ClassResolver class_resolver = self.fory.class_resolver
+ cdef TypeResolver type_resolver = self.fory.type_resolver
map_ = self.type_()
ref_resolver.reference(map_)
cdef int32_t len_ = buffer.read_varuint32()
cdef int32_t ref_id
- cdef ClassInfo key_classinfo
- cdef ClassInfo value_classinfo
+ cdef TypeInfo key_typeinfo
+ cdef TypeInfo value_typeinfo
for i in range(len_):
ref_id = ref_resolver.try_preserve_ref_id(buffer)
if ref_id < NOT_NULL_VALUE_FLAG:
key = ref_resolver.get_read_object()
else:
- key_classinfo = class_resolver.read_typeinfo(buffer)
- if key_classinfo.cls is str:
+ key_typeinfo = type_resolver.read_typeinfo(buffer)
+ if key_typeinfo.cls is str:
key = buffer.read_string()
else:
- key = key_classinfo.serializer.read(buffer)
+ key = key_typeinfo.serializer.read(buffer)
ref_resolver.set_read_object(ref_id, key)
ref_id = ref_resolver.try_preserve_ref_id(buffer)
if ref_id < NOT_NULL_VALUE_FLAG:
value = ref_resolver.get_read_object()
else:
- value_classinfo = class_resolver.read_typeinfo(buffer)
- cls = value_classinfo.cls
+ value_typeinfo = type_resolver.read_typeinfo(buffer)
+ cls = value_typeinfo.cls
if cls is str:
value = buffer.read_string()
elif cls is int:
@@ -2106,7 +2106,7 @@ cdef class SubMapSerializer(Serializer):
elif cls is float:
value = buffer.read_double()
else:
- value = value_classinfo.serializer.read(buffer)
+ value = value_typeinfo.serializer.read(buffer)
ref_resolver.set_read_object(ref_id, value)
map_[key] = value
return map_
diff --git a/python/pyfory/_serializer.py b/python/pyfory/_serializer.py
index 7ef98b29..dacdae67 100644
--- a/python/pyfory/_serializer.py
+++ b/python/pyfory/_serializer.py
@@ -229,7 +229,7 @@ COLLECTION_NOT_SAME_TYPE = 0b1000
class CollectionSerializer(Serializer):
__slots__ = (
- "class_resolver",
+ "type_resolver",
"ref_resolver",
"elem_serializer",
"is_py",
@@ -240,16 +240,16 @@ class CollectionSerializer(Serializer):
def __init__(self, fory, type_, elem_serializer=None):
super().__init__(fory, type_)
- self.class_resolver = fory.class_resolver
+ self.type_resolver = fory.type_resolver
self.ref_resolver = fory.ref_resolver
self.elem_serializer = elem_serializer
if elem_serializer is None:
self.elem_type = None
- self.elem_typeinfo = self.class_resolver.get_classinfo(None)
+ self.elem_typeinfo = self.type_resolver.get_typeinfo(None)
self.elem_tracking_ref = -1
else:
self.elem_type = elem_serializer.type_
- self.elem_typeinfo =
fory.class_resolver.get_classinfo(self.elem_type)
+ self.elem_typeinfo =
fory.type_resolver.get_typeinfo(self.elem_type)
self.elem_tracking_ref = int(elem_serializer.need_to_write_ref)
self.is_py = fory.is_py
@@ -271,7 +271,7 @@ class CollectionSerializer(Serializer):
collect_flag |= COLLECTION_NOT_SAME_TYPE
has_different_type = True
if not has_different_type and elem_type is not None:
- elem_typeinfo = self.class_resolver.get_classinfo(elem_type)
+ elem_typeinfo = self.type_resolver.get_typeinfo(elem_type)
else:
for s in value:
if s is None:
@@ -291,49 +291,49 @@ class CollectionSerializer(Serializer):
not has_different_type
and (collect_flag & COLLECTION_NOT_DECL_ELEMENT_TYPE) != 0
):
- self.class_resolver.write_typeinfo(buffer, elem_typeinfo)
+ self.type_resolver.write_typeinfo(buffer, elem_typeinfo)
return collect_flag, elem_typeinfo
def write(self, buffer, value):
if len(value) == 0:
buffer.write_varuint32(0)
return
- collect_flag, classinfo = self.write_header(buffer, value)
+ collect_flag, typeinfo = self.write_header(buffer, value)
if (collect_flag & COLLECTION_NOT_SAME_TYPE) == 0:
if (collect_flag & COLLECTION_TRACKING_REF) == 0:
- self._write_same_type_no_ref(buffer, value, classinfo)
+ self._write_same_type_no_ref(buffer, value, typeinfo)
else:
- self._write_same_type_ref(buffer, value, classinfo)
+ self._write_same_type_ref(buffer, value, typeinfo)
else:
self._write_different_types(buffer, value)
- def _write_same_type_no_ref(self, buffer, value, classinfo):
+ def _write_same_type_no_ref(self, buffer, value, typeinfo):
if self.is_py:
for s in value:
- classinfo.serializer.write(buffer, s)
+ typeinfo.serializer.write(buffer, s)
else:
for s in value:
- classinfo.serializer.xwrite(buffer, s)
+ typeinfo.serializer.xwrite(buffer, s)
- def _write_same_type_ref(self, buffer, value, classinfo):
+ def _write_same_type_ref(self, buffer, value, typeinfo):
if self.is_py:
for s in value:
if not self.ref_resolver.write_ref_or_null(buffer, s):
- classinfo.serializer.write(buffer, s)
+ typeinfo.serializer.write(buffer, s)
else:
for s in value:
if not self.ref_resolver.write_ref_or_null(buffer, s):
- classinfo.serializer.xwrite(buffer, s)
+ typeinfo.serializer.xwrite(buffer, s)
def _write_different_types(self, buffer, value):
for s in value:
if not self.ref_resolver.write_ref_or_null(buffer, s):
- classinfo = self.class_resolver.get_classinfo(type(s))
- self.class_resolver.write_typeinfo(buffer, classinfo)
+ typeinfo = self.type_resolver.get_typeinfo(type(s))
+ self.type_resolver.write_typeinfo(buffer, typeinfo)
if self.is_py:
- classinfo.serializer.write(buffer, s)
+ typeinfo.serializer.write(buffer, s)
else:
- classinfo.serializer.xwrite(buffer, s)
+ typeinfo.serializer.xwrite(buffer, s)
def read(self, buffer):
len_ = buffer.read_varuint32()
@@ -343,13 +343,13 @@ class CollectionSerializer(Serializer):
collect_flag = buffer.read_int8()
if (collect_flag & COLLECTION_NOT_SAME_TYPE) == 0:
if collect_flag & COLLECTION_NOT_DECL_ELEMENT_TYPE != 0:
- classinfo = self.class_resolver.read_typeinfo(buffer)
+ typeinfo = self.type_resolver.read_typeinfo(buffer)
else:
- classinfo = self.elem_typeinfo
+ typeinfo = self.elem_typeinfo
if (collect_flag & COLLECTION_TRACKING_REF) == 0:
- self._read_same_type_no_ref(buffer, len_, collection_,
classinfo)
+ self._read_same_type_no_ref(buffer, len_, collection_,
typeinfo)
else:
- self._read_same_type_ref(buffer, len_, collection_, classinfo)
+ self._read_same_type_ref(buffer, len_, collection_, typeinfo)
else:
self._read_different_types(buffer, len_, collection_)
return collection_
@@ -360,24 +360,24 @@ class CollectionSerializer(Serializer):
def _add_element(self, collection_, element):
raise NotImplementedError
- def _read_same_type_no_ref(self, buffer, len_, collection_, classinfo):
+ def _read_same_type_no_ref(self, buffer, len_, collection_, typeinfo):
if self.is_py:
for _ in range(len_):
- self._add_element(collection_,
classinfo.serializer.read(buffer))
+ self._add_element(collection_,
typeinfo.serializer.read(buffer))
else:
for _ in range(len_):
- self._add_element(collection_,
classinfo.serializer.xread(buffer))
+ self._add_element(collection_,
typeinfo.serializer.xread(buffer))
- def _read_same_type_ref(self, buffer, len_, collection_, classinfo):
+ def _read_same_type_ref(self, buffer, len_, collection_, typeinfo):
for _ in range(len_):
ref_id = self.ref_resolver.try_preserve_ref_id(buffer)
if ref_id < NOT_NULL_VALUE_FLAG:
obj = self.ref_resolver.get_read_object()
else:
if self.is_py:
- obj = classinfo.serializer.read(buffer)
+ obj = typeinfo.serializer.read(buffer)
else:
- obj = classinfo.serializer.xread(buffer)
+ obj = typeinfo.serializer.xread(buffer)
self.ref_resolver.set_read_object(ref_id, obj)
self._add_element(collection_, obj)
@@ -386,7 +386,7 @@ class CollectionSerializer(Serializer):
self._add_element(
collection_,
get_next_element(
- buffer, self.ref_resolver, self.class_resolver, self.is_py
+ buffer, self.ref_resolver, self.type_resolver, self.is_py
),
)
@@ -433,15 +433,15 @@ class SetSerializer(CollectionSerializer):
collection_.add(element)
-def get_next_element(buffer, ref_resolver, class_resolver, is_py):
+def get_next_element(buffer, ref_resolver, type_resolver, is_py):
ref_id = ref_resolver.try_preserve_ref_id(buffer)
if ref_id < NOT_NULL_VALUE_FLAG:
return ref_resolver.get_read_object()
- classinfo = class_resolver.read_typeinfo(buffer)
+ typeinfo = type_resolver.read_typeinfo(buffer)
if is_py:
- obj = classinfo.serializer.read(buffer)
+ obj = typeinfo.serializer.read(buffer)
else:
- obj = classinfo.serializer.xread(buffer)
+ obj = typeinfo.serializer.xread(buffer)
ref_resolver.set_read_object(ref_id, obj)
return obj
@@ -449,7 +449,7 @@ def get_next_element(buffer, ref_resolver, class_resolver,
is_py):
class MapSerializer(Serializer):
def __init__(self, fory, type_, key_serializer=None,
value_serializer=None):
super().__init__(fory, type_)
- self.class_resolver = fory.class_resolver
+ self.type_resolver = fory.type_resolver
self.ref_resolver = fory.ref_resolver
self.key_serializer = key_serializer
self.value_serializer = value_serializer
@@ -461,7 +461,7 @@ class MapSerializer(Serializer):
if length == 0:
return
fory = self.fory
- class_resolver = fory.class_resolver
+ type_resolver = fory.type_resolver
ref_resolver = fory.ref_resolver
key_serializer = self.key_serializer
value_serializer = self.value_serializer
@@ -521,16 +521,16 @@ class MapSerializer(Serializer):
if key_serializer is not None:
chunk_header |= KEY_DECL_TYPE
else:
- key_classinfo = self.class_resolver.get_classinfo(key_cls)
- class_resolver.write_typeinfo(buffer, key_classinfo)
- key_serializer = key_classinfo.serializer
+ key_typeinfo = self.type_resolver.get_typeinfo(key_cls)
+ type_resolver.write_typeinfo(buffer, key_typeinfo)
+ key_serializer = key_typeinfo.serializer
if value_serializer is not None:
chunk_header |= VALUE_DECL_TYPE
else:
- value_classinfo = self.class_resolver.get_classinfo(value_cls)
- class_resolver.write_typeinfo(buffer, value_classinfo)
- value_serializer = value_classinfo.serializer
+ value_typeinfo = self.type_resolver.get_typeinfo(value_cls)
+ type_resolver.write_typeinfo(buffer, value_typeinfo)
+ value_serializer = value_typeinfo.serializer
key_write_ref = (
key_serializer.need_to_write_ref if key_serializer else False
@@ -575,7 +575,7 @@ class MapSerializer(Serializer):
def read(self, buffer):
fory = self.fory
ref_resolver = self.ref_resolver
- class_resolver = self.class_resolver
+ type_resolver = self.type_resolver
size = buffer.read_varuint32()
map_ = {}
ref_resolver.reference(map_)
@@ -636,9 +636,9 @@ class MapSerializer(Serializer):
value_is_declared_type = (chunk_header & VALUE_DECL_TYPE) != 0
chunk_size = buffer.read_uint8()
if not key_is_declared_type:
- key_serializer =
class_resolver.read_typeinfo(buffer).serializer
+ key_serializer = type_resolver.read_typeinfo(buffer).serializer
if not value_is_declared_type:
- value_serializer =
class_resolver.read_typeinfo(buffer).serializer
+ value_serializer =
type_resolver.read_typeinfo(buffer).serializer
for i in range(chunk_size):
if track_key_ref:
ref_id = ref_resolver.try_preserve_ref_id(buffer)
diff --git a/python/pyfory/_struct.py b/python/pyfory/_struct.py
index 96a1bf46..e71be2ab 100644
--- a/python/pyfory/_struct.py
+++ b/python/pyfory/_struct.py
@@ -21,7 +21,7 @@ import logging
import typing
from pyfory.buffer import Buffer
-from pyfory.error import ClassNotCompatibleError
+from pyfory.error import TypeNotCompatibleError
from pyfory.serializer import (
ListSerializer,
MapSerializer,
@@ -96,10 +96,10 @@ class ComplexTypeVisitor(TypeVisitor):
def visit_other(self, field_name, type_, types_path=None):
if is_subclass(type_, enum.Enum):
- return self.fory.class_resolver.get_serializer(type_)
+ return self.fory.type_resolver.get_serializer(type_)
if type_ not in basic_types and not is_py_array_type(type_):
return None
- serializer = self.fory.class_resolver.get_serializer(type_)
+ serializer = self.fory.type_resolver.get_serializer(type_)
assert not isinstance(serializer, (PickleSerializer,))
return serializer
@@ -117,7 +117,7 @@ _UNKNOWN_TYPE_ID = -1
_time_types = {datetime.date, datetime.datetime, datetime.timedelta}
-def _sort_fields(class_resolver, field_names, serializers):
+def _sort_fields(type_resolver, field_names, serializers):
boxed_types = []
collection_types = []
map_types = []
@@ -130,7 +130,7 @@ def _sort_fields(class_resolver, field_names, serializers):
else:
type_ids.append(
(
- class_resolver.get_classinfo(serializer.type_).type_id,
+ type_resolver.get_typeinfo(serializer.type_).type_id,
serializer,
field_name,
)
@@ -185,7 +185,7 @@ class ComplexObjectSerializer(Serializer):
serializer = infer_field(key, self._type_hints[key], visitor,
types_path=[])
self._serializers[index] = serializer
self._serializers, self._field_names = _sort_fields(
- fory.class_resolver, self._field_names, self._serializers
+ fory.type_resolver, self._field_names, self._serializers
)
from pyfory import Language
@@ -218,9 +218,9 @@ class ComplexObjectSerializer(Serializer):
self._hash = _get_hash(self.fory, self._field_names,
self._type_hints)
hash_ = buffer.read_int32()
if hash_ != self._hash:
- raise ClassNotCompatibleError(
+ raise TypeNotCompatibleError(
f"Hash {hash_} is not consistent with {self._hash} "
- f"for class {self.type_}",
+ f"for type {self.type_}",
)
obj = self.type_.__new__(self.type_)
self.fory.ref_resolver.reference(obj)
@@ -245,33 +245,31 @@ class StructHashVisitor(TypeVisitor):
def visit_list(self, field_name, elem_type, types_path=None):
# TODO add list element type to hash.
- xtype_id = self.fory.class_resolver.get_classinfo(list).type_id
+ xtype_id = self.fory.type_resolver.get_typeinfo(list).type_id
self._hash = self._compute_field_hash(self._hash, abs(xtype_id))
def visit_dict(self, field_name, key_type, value_type, types_path=None):
# TODO add map key/value type to hash.
- xtype_id = self.fory.class_resolver.get_classinfo(dict).type_id
+ xtype_id = self.fory.type_resolver.get_typeinfo(dict).type_id
self._hash = self._compute_field_hash(self._hash, abs(xtype_id))
def visit_customized(self, field_name, type_, types_path=None):
- classinfo = self.fory.class_resolver.get_classinfo(type_, create=False)
+ typeinfo = self.fory.type_resolver.get_typeinfo(type_, create=False)
hash_value = 0
- if classinfo is not None:
- hash_value = classinfo.type_id
- if TypeId.is_namespaced_type(classinfo.type_id):
- hash_value = compute_string_hash(
- classinfo.namespace + classinfo.typename
- )
+ if typeinfo is not None:
+ hash_value = typeinfo.type_id
+ if TypeId.is_namespaced_type(typeinfo.type_id):
+ hash_value = compute_string_hash(typeinfo.namespace +
typeinfo.typename)
self._hash = self._compute_field_hash(self._hash, hash_value)
def visit_other(self, field_name, type_, types_path=None):
- classinfo = self.fory.class_resolver.get_classinfo(type_, create=False)
- if classinfo is None:
+ typeinfo = self.fory.type_resolver.get_typeinfo(type_, create=False)
+ if typeinfo is None:
id_ = 0
else:
- serializer = classinfo.serializer
+ serializer = typeinfo.serializer
assert not isinstance(serializer, (PickleSerializer,))
- id_ = classinfo.type_id
+ id_ = typeinfo.type_id
assert id_ is not None, serializer
id_ = abs(id_)
self._hash = self._compute_field_hash(self._hash, id_)
diff --git a/python/pyfory/error.py b/python/pyfory/error.py
index 6fb94cc9..84d3173a 100644
--- a/python/pyfory/error.py
+++ b/python/pyfory/error.py
@@ -20,7 +20,7 @@ class ForyError(Exception):
pass
-class ClassNotCompatibleError(ForyError):
+class TypeNotCompatibleError(ForyError):
pass
diff --git a/python/pyfory/format/infer.py b/python/pyfory/format/infer.py
index 1de2e0c5..551db3cc 100644
--- a/python/pyfory/format/infer.py
+++ b/python/pyfory/format/infer.py
@@ -24,13 +24,13 @@ from functools import partial
from typing import Optional
from pyfory.type import get_qualified_classname, TypeVisitor, infer_field
-__class_map__ = {}
+__type_map__ = {}
__schemas__ = {} # ensure `id(schema)` doesn't get duplicate.
def get_cls_by_schema(schema):
id_ = id(schema)
- if id_ not in __class_map__:
+ if id_ not in __type_map__:
meta = {} if schema.metadata is None else schema.metadata
cls_name = meta.get(b"cls", b"").decode()
if cls_name:
@@ -45,9 +45,9 @@ def get_cls_by_schema(schema):
cls_ = record_class_factory(
"Record" + str(id(schema)), [f.name for f in schema]
)
- __class_map__[id_] = cls_
+ __type_map__[id_] = cls_
__schemas__[id_] = schema
- return __class_map__[id_]
+ return __type_map__[id_]
def remove_schema(schema):
@@ -55,7 +55,7 @@ def remove_schema(schema):
def reset():
- __class_map__.clear()
+ __type_map__.clear()
__schemas__.clear()
diff --git a/python/pyfory/serializer.py b/python/pyfory/serializer.py
index aafb8a29..6437c62e 100644
--- a/python/pyfory/serializer.py
+++ b/python/pyfory/serializer.py
@@ -29,7 +29,7 @@ from pyfory.codegen import (
gen_read_nullable_basic_stmts,
compile_function,
)
-from pyfory.error import ClassNotCompatibleError
+from pyfory.error import TypeNotCompatibleError
from pyfory.lib.collection import WeakIdentityKeyDictionary
from pyfory.resolver import NULL_FLAG, NOT_NULL_VALUE_FLAG
@@ -357,7 +357,7 @@ class DataClassSerializer(Serializer):
f"{ref_resolver}.reference({obj})",
f"read_hash = {buffer}.read_int32()",
f"if read_hash != {self._hash}:",
- f""" raise ClassNotCompatibleError(
+ f""" raise TypeNotCompatibleError(
"Hash read_hash is not consistent with {self._hash} for
{self.type_}")""",
]
if not self._has_slots:
@@ -399,9 +399,9 @@ class DataClassSerializer(Serializer):
def read(self, buffer):
hash_ = buffer.read_int32()
if hash_ != self._hash:
- raise ClassNotCompatibleError(
+ raise TypeNotCompatibleError(
f"Hash {hash_} is not consistent with {self._hash} "
- f"for class {self.type_}",
+ f"for type {self.type_}",
)
obj = self.type_.__new__(self.type_)
self.fory.ref_resolver.reference(obj)
@@ -536,7 +536,7 @@ class DynamicPyArraySerializer(Serializer):
return arr
def write(self, buffer, value):
- buffer.write_varuint32(PickleSerializer.PICKLE_CLASS_ID)
+ buffer.write_varuint32(PickleSerializer.PICKLE_TYPE_ID)
self.fory.handle_unsupported_write(buffer, value)
def read(self, buffer):
@@ -598,7 +598,7 @@ class Numpy1DArraySerializer(Serializer):
return np.frombuffer(data, dtype=self.dtype)
def write(self, buffer, value):
- buffer.write_int8(PickleSerializer.PICKLE_CLASS_ID)
+ buffer.write_int8(PickleSerializer.PICKLE_TYPE_ID)
self.fory.handle_unsupported_write(buffer, value)
def read(self, buffer):
@@ -621,7 +621,7 @@ class NDArraySerializer(Serializer):
raise NotImplementedError("Multi-dimensional array not supported
currently")
def write(self, buffer, value):
- buffer.write_int8(PickleSerializer.PICKLE_CLASS_ID)
+ buffer.write_int8(PickleSerializer.PICKLE_TYPE_ID)
self.fory.handle_unsupported_write(buffer, value)
def read(self, buffer):
@@ -654,7 +654,7 @@ class BytesBufferObject(BufferObject):
class PickleSerializer(Serializer):
- PICKLE_CLASS_ID = 96
+ PICKLE_TYPE_ID = 96
def xwrite(self, buffer, value):
raise NotImplementedError
diff --git a/python/pyfory/tests/test_cross_language.py
b/python/pyfory/tests/test_cross_language.py
index 789d20d4..f04627ce 100644
--- a/python/pyfory/tests/test_cross_language.py
+++ b/python/pyfory/tests/test_cross_language.py
@@ -495,7 +495,7 @@ def test_struct_hash(data_file_path):
read_hash = pyfory.Buffer(data_bytes).read_int32()
fory = pyfory.Fory(language=pyfory.Language.XLANG, ref_tracking=True)
fory.register_type(ComplexObject1, typename="ComplexObject1")
- serializer = fory.class_resolver.get_serializer(ComplexObject1)
+ serializer = fory.type_resolver.get_serializer(ComplexObject1)
from pyfory._struct import _get_hash
v = _get_hash(fory, serializer._field_names, serializer._type_hints)
diff --git a/python/pyfory/tests/test_serializer.py
b/python/pyfory/tests/test_serializer.py
index da481c24..3daeaca2 100644
--- a/python/pyfory/tests/test_serializer.py
+++ b/python/pyfory/tests/test_serializer.py
@@ -52,7 +52,7 @@ def test_float():
fory = Fory(language=Language.PYTHON, ref_tracking=True)
assert ser_de(fory, -1.0) == -1.0
assert ser_de(fory, 1 / 3) == 1 / 3
- serializer = fory.class_resolver.get_serializer(float)
+ serializer = fory.type_resolver.get_serializer(float)
assert type(serializer) is pyfory.Float64Serializer
@@ -130,18 +130,18 @@ 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)
- classinfo = fory.class_resolver.get_classinfo(datetime.datetime)
+ typeinfo = fory.type_resolver.get_typeinfo(datetime.datetime)
assert isinstance(
- classinfo.serializer, (TimestampSerializer,
_serialization.TimestampSerializer)
+ typeinfo.serializer, (TimestampSerializer,
_serialization.TimestampSerializer)
)
if language == Language.XLANG:
- assert classinfo.type_id == TypeId.TIMESTAMP
- classinfo = fory.class_resolver.get_classinfo(datetime.date)
+ assert typeinfo.type_id == TypeId.TIMESTAMP
+ typeinfo = fory.type_resolver.get_typeinfo(datetime.date)
assert isinstance(
- classinfo.serializer, (DateSerializer, _serialization.DateSerializer)
+ typeinfo.serializer, (DateSerializer, _serialization.DateSerializer)
)
if language == Language.XLANG:
- assert classinfo.type_id == TypeId.LOCAL_DATE
+ assert typeinfo.type_id == TypeId.LOCAL_DATE
assert ser_de(fory, True) is True
assert ser_de(fory, False) is False
assert ser_de(fory, -1) == -1
@@ -256,7 +256,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_class_registration=False)
+ fory = Fory(language=language, ref_tracking=True,
require_type_registration=False)
# TODO support Language.XLANG, current unpickler will error for xlang,
o1 = RefTestClass1()
o2 = RefTestClass2(f1=o1)
@@ -273,7 +273,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_class_registration=False)
+ fory = Fory(language=language, ref_tracking=True,
require_type_registration=False)
for typecode in PyArraySerializer.typecode_dict.keys():
arr = array.array(typecode, list(range(10)))
new_arr = ser_de(fory, arr)
@@ -410,7 +410,7 @@ class RegisterClass:
def test_register_py_serializer():
fory = Fory(
- language=Language.PYTHON, ref_tracking=True,
require_class_registration=False
+ language=Language.PYTHON, ref_tracking=True,
require_type_registration=False
)
class Serializer(pyfory.Serializer):
@@ -464,7 +464,7 @@ def test_register_type():
def test_pickle_fallback():
fory = Fory(
- language=Language.PYTHON, ref_tracking=True,
require_class_registration=False
+ language=Language.PYTHON, ref_tracking=True,
require_type_registration=False
)
o1 = [1, True, np.dtype(np.int32)]
data1 = fory.serialize(o1)
@@ -478,7 +478,7 @@ def test_pickle_fallback():
def test_unsupported_callback():
fory = Fory(
- language=Language.PYTHON, ref_tracking=True,
require_class_registration=False
+ language=Language.PYTHON, ref_tracking=True,
require_type_registration=False
)
def f1(x):
@@ -534,7 +534,7 @@ def test_enum():
assert ser_de(fory, EnumClass.E2) == EnumClass.E2
assert ser_de(fory, EnumClass.E3) == EnumClass.E3
assert ser_de(fory, EnumClass.E4) == EnumClass.E4
- assert isinstance(fory.class_resolver.get_serializer(EnumClass),
EnumSerializer)
+ assert isinstance(fory.type_resolver.get_serializer(EnumClass),
EnumSerializer)
def test_duplicate_serialize():
@@ -562,7 +562,7 @@ def test_cache_serializer():
def test_pandas_range_index():
fory = Fory(
- language=Language.PYTHON, ref_tracking=True,
require_class_registration=False
+ language=Language.PYTHON, ref_tracking=True,
require_type_registration=False
)
fory.register_type(
pd.RangeIndex, serializer=pyfory.PandasRangeIndexSerializer(fory)
@@ -585,7 +585,7 @@ class PyDataClass1:
def test_py_serialize_dataclass():
fory = Fory(
- language=Language.PYTHON, ref_tracking=True,
require_class_registration=False
+ language=Language.PYTHON, ref_tracking=True,
require_type_registration=False
)
obj1 = PyDataClass1(
f1=1, f2=-2.0, f3="abc", f4=True, f5="xyz", f6=[1, 2], f7={"k1": "v1"}
@@ -597,7 +597,7 @@ def test_py_serialize_dataclass():
def test_function():
fory = Fory(
- language=Language.PYTHON, ref_tracking=True,
require_class_registration=False
+ language=Language.PYTHON, ref_tracking=True,
require_type_registration=False
)
c = fory.deserialize(fory.serialize(lambda x: x * 2))
assert c(2) == 4
@@ -622,7 +622,7 @@ class MapFields:
def test_map_fields_chunk_serializer():
fory = Fory(
- language=Language.PYTHON, ref_tracking=True,
require_class_registration=False
+ language=Language.PYTHON, ref_tracking=True,
require_type_registration=False
)
simple_dict = {"a": 1, "b": 2, "c": 3}
diff --git a/python/pyfory/tests/test_struct.py
b/python/pyfory/tests/test_struct.py
index a3f63221..7e65acdb 100644
--- a/python/pyfory/tests/test_struct.py
+++ b/python/pyfory/tests/test_struct.py
@@ -93,7 +93,7 @@ class ChildClass1(SuperClass1):
f3: Dict[str, pyfory.Float64Type] = None
-def test_require_class_registration():
+def test_require_type_registration():
fory = Fory(language=Language.PYTHON, ref_tracking=True)
obj = ChildClass1(f1="a", f2=-10, f3={"a": -10.0, "b": 1 / 3})
with pytest.raises(TypeUnregisteredError):
@@ -105,11 +105,11 @@ def test_inheritance():
print(type_hints)
assert type_hints.keys() == {"f1", "f2", "f3"}
fory = Fory(
- language=Language.PYTHON, ref_tracking=True,
require_class_registration=False
+ language=Language.PYTHON, ref_tracking=True,
require_type_registration=False
)
obj = ChildClass1(f1="a", f2=-10, f3={"a": -10.0, "b": 1 / 3})
assert ser_de(fory, obj) == obj
assert (
- type(fory.class_resolver.get_serializer(ChildClass1))
+ type(fory.type_resolver.get_serializer(ChildClass1))
== pyfory.DataClassSerializer
)
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
