Customized Encoding
The v8serialize.encode module writes V8-serialized data.
default_encode_steps
default_encode_steps
The default sequence of encode steps used to map Python objects to JavaScript values.
The defaults represent common Python types as their JavaScript equivalents, and serializes the v8serialize.jstypes.JS* types as their corresponding JavaScript type.
This sequence contains serialize_object_references and an instance of TagWriter.
encode.serialize_object_references
encode.serialize_object_references(value, /, ctx, next)
Serialize references to previously-seen objects instead of duplicating them.
Objects that have already been written to the stream are written as references to the original instance. This:
- Avoids duplication of data.
- Preserves object identity after de-serializing.
- Allows cyclic object hierarchies to be serialized and deserialized without causing infinite loops.
Notes
This is an encode step that can be used as one of the encode_steps with dumps() or Encoder().
encode.TagWriter
encode.TagWriter(self)
Defines the conversion of Python types into the V8 serialization format.
TagWriters are responsible for making suitable calls to a WritableTagStream to represent Python objects with the various encoded representations supported by the V8 serialization format.
The stream delegates back to the EncodeContext when writing hierarchical objects, like arrays, to let the context pass sub-values through a sequence of encode steps, typically ending with a TagWriter as the final step.
Methods
encode
encode.TagWriter.encode(value, /, ctx, next)
serialize_bool
encode.TagWriter.serialize_bool(value, /, ctx, next)
serialize_buffer
encode.TagWriter.serialize_buffer(value, /, ctx, next)
serialize_buffer_view
encode.TagWriter.serialize_buffer_view(value, /, ctx, next)
serialize_collection
encode.TagWriter.serialize_collection(value, /, ctx, next)
serialize_float
encode.TagWriter.serialize_float(value, /, ctx, next)
serialize_hole
encode.TagWriter.serialize_hole(value, /, ctx, next)
serialize_int
encode.TagWriter.serialize_int(value, /, ctx, next)
serialize_js_array
encode.TagWriter.serialize_js_array(value, /, ctx, next)
serialize_js_array_buffer
encode.TagWriter.serialize_js_array_buffer(value, /, ctx, next)
serialize_js_error
encode.TagWriter.serialize_js_error(value, /, ctx, next)
serialize_js_object
encode.TagWriter.serialize_js_object(value, /, ctx, next)
serialize_js_primitive_object
encode.TagWriter.serialize_js_primitive_object(value, /, ctx, next)
serialize_js_regexp
encode.TagWriter.serialize_js_regexp(value, /, ctx, next)
serialize_mapping
encode.TagWriter.serialize_mapping(value, /, ctx, next)
serialize_none
encode.TagWriter.serialize_none(value, /, ctx, next)
serialize_python_datetime
encode.TagWriter.serialize_python_datetime(value, /, ctx, next)
serialize_python_exception
encode.TagWriter.serialize_python_exception(value, /, ctx, next)
serialize_python_regexp
encode.TagWriter.serialize_python_regexp(value, /, ctx, next)
serialize_set
encode.TagWriter.serialize_set(value, /, ctx, next)
serialize_str
encode.TagWriter.serialize_str(value, /, ctx, next)
serialize_undefined
encode.TagWriter.serialize_undefined(value, /, ctx, next)
encode.DefaultEncodeContext
encode.DefaultEncodeContext(self, encode_steps=None, *, stream=None, deduplicate_max_size=None)
Attributes
| Name | Description |
|---|---|
| encode_steps | |
| stream |
Methods
| Name | Description |
|---|---|
| deduplicate | |
| encode_object | Serialize a single Python value to the stream. |
deduplicate
encode.DefaultEncodeContext.deduplicate(value)
encode_object
encode.DefaultEncodeContext.encode_object(value)
Serialize a single Python value to the stream.
The encode_steps convert the Python value to JavaScript representation, and the stream writes out V8 serialization format tagged data.
encode.WritableTagStream
encode.WritableTagStream(self, data=bytearray(), objects=SerializedObjectLog(), features=SerializationFeature.MaxCompatibility)
Write individual tagged data items in the V8 serialization format.
This is a low-level interface to incrementally generate a V8 serialization byte stream.
Attributes
| Name | Description |
|---|---|
| allowed_tags | When set, only tags allowed by the constraint may be written. |
| data | |
| features | |
| objects | |
| pos |
Methods
| Name | Description |
|---|---|
| constrain_tags | Prevent writing tags to the stream which are not allowed in a given context. |
| write_bigint | |
| write_constant | |
| write_double | |
| write_header | Write the V8 serialization stream header. |
| write_host_object | |
| write_int32 | |
| write_js_array_buffer | |
| write_js_array_buffer_view | |
| write_js_array_dense | |
| write_js_array_sparse | |
| write_js_date | |
| write_js_error | |
| write_js_object | |
| write_js_primitive_object | |
| write_js_regexp | |
| write_jsmap | |
| write_jsset | |
| write_object_reference | |
| write_string_onebyte | Encode a OneByte string, which is latin1-encoded text. |
| write_string_twobyte | |
| write_string_utf8 | Encode a Utf8String, which is UTF-8-encoded text. |
| write_tag | |
| write_uint32 | |
| write_v8_shared_object_reference | |
| write_varint | |
| write_zigzag |
write_bigint
encode.WritableTagStream.write_bigint(value, *, tag=SerializationTag.kBigInt)
write_constant
encode.WritableTagStream.write_constant(constant)
write_double
encode.WritableTagStream.write_double(value, *, tag=SerializationTag.kDouble)
write_header
encode.WritableTagStream.write_header()
Write the V8 serialization stream header.
write_host_object
encode.WritableTagStream.write_host_object(value, *, serializer)
write_int32
encode.WritableTagStream.write_int32(value, *, tag=SerializationTag.kInt32)
write_js_array_buffer
encode.WritableTagStream.write_js_array_buffer(buffer, *, identity=None)
write_js_array_buffer_view
encode.WritableTagStream.write_js_array_buffer_view(buffer_view, *, identity=None)
write_js_array_dense
encode.WritableTagStream.write_js_array_dense(array, ctx, *, properties=None, identity=None)
write_js_array_sparse
encode.WritableTagStream.write_js_array_sparse(items, ctx, *, length, identity=None)
write_js_date
encode.WritableTagStream.write_js_date(value, *, identity=None)
write_js_error
encode.WritableTagStream.write_js_error(error, ctx, *, identity=None)
write_js_object
encode.WritableTagStream.write_js_object(items, ctx, *, identity=None)
write_js_primitive_object
encode.WritableTagStream.write_js_primitive_object(obj, *, identity=None)
write_js_regexp
encode.WritableTagStream.write_js_regexp(regexp, *, identity=None)
write_jsmap
encode.WritableTagStream.write_jsmap(items, ctx, *, identity=None)
write_jsset
encode.WritableTagStream.write_jsset(values, ctx, *, identity=None)
write_object_reference
encode.WritableTagStream.write_object_reference(obj=None, serialized_id=None)
write_string_onebyte
encode.WritableTagStream.write_string_onebyte(value, *, tag=SerializationTag.kOneByteString)
Encode a OneByte string, which is latin1-encoded text.
write_string_twobyte
encode.WritableTagStream.write_string_twobyte(value, *, tag=SerializationTag.kTwoByteString)
write_string_utf8
encode.WritableTagStream.write_string_utf8(value, *, tag=SerializationTag.kUtf8String)
Encode a Utf8String, which is UTF-8-encoded text.
Note: We never encode Utf8String at runtime, but we use it to test the decoder. The V8 implementation only decodes Utf8String.
write_tag
encode.WritableTagStream.write_tag(tag)
write_uint32
encode.WritableTagStream.write_uint32(value, *, tag=SerializationTag.kUint32)
write_varint
encode.WritableTagStream.write_varint(n)
write_zigzag
encode.WritableTagStream.write_zigzag(n)
encode.TagConstraintRemover
encode.TagConstraintRemover(self, stream)
Context manager that resets the tag constraint on a WritableTagStream.
Upon exiting, the stream’s allowed_tags is reset back to None allowing any tag to be written.
Attributes
| Name | Description |
|---|---|
| stream |
encode.HostObjectSerializer
encode.HostObjectSerializer
Either a HostObjectSerializerObj or HostObjectSerializerFn.