Microsoft Kiota Serialization Form

Warnings

• breaking Support for Python 3.9 was dropped in version 1.10.0 across all Kiota Python libraries.
  Fix: Upgrade your Python environment to 3.10 or newer (up to <4.0).
• gotcha This library only handles `application/x-www-form-urlencoded` content types. For other formats like JSON or plain text, you need to install and use their respective Kiota serialization packages (e.g., `microsoft-kiota-serialization-json`).
  Fix: Ensure the `Content-Type` header matches `application/x-www-form-urlencoded` when using this factory. For other formats, install the relevant `microsoft-kiota-serialization-*` package.
• gotcha Kiota's serialization/deserialization relies on models implementing the `Parsable` interface, which can be verbose for simple data structures. You must define `get_field_deserializers` and `serialize` methods.
  Fix: Carefully define your data models to adhere to the `Parsable` interface, including mapping fields to their deserializer functions and implementing the `serialize` method.

Install

• pip install microsoft-kiota-serialization-form Install latest version

Imports

• FormSerializationWriterFactory

  from microsoft_kiota_serialization_form import FormSerializationWriterFactory

• FormParseNodeFactory

  from microsoft_kiota_serialization_form import FormParseNodeFactory

Quickstart

This example demonstrates how to serialize a Python object into `application/x-www-form-urlencoded` format and then deserialize it back, using `FormSerializationWriterFactory` and `FormParseNodeFactory`. It requires defining a data model that implements Kiota's `Parsable` interface.

from typing import Callable, Dict, Optional
from microsoft_kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
from microsoft_kiota_serialization_form import FormParseNodeFactory, FormSerializationWriterFactory

# 1. Define a simple model that implements Kiota's Parsable and AdditionalDataHolder
class MyFormModel(Parsable, AdditionalDataHolder):
    def __init__(self) -> None:
        self._my_string: Optional[str] = None
        self._my_int: Optional[int] = None
        self._additional_data: Dict[str, object] = {}

    @property
    def my_string(self) -> Optional[str]:
        return self._my_string

    @my_string.setter
    def my_string(self, value: Optional[str]) -> None:
        self._my_string = value

    @property
    def my_int(self) -> Optional[int]:
        return self._my_int

    @my_int.setter
    def my_int(self, value: Optional[int]) -> None:
        self._my_int = value

    @property
    def additional_data(self) -> Dict[str, object]:
        return self._additional_data

    @additional_data.setter
    def additional_data(self, value: Dict[str, object]) -> None:
        self._additional_data = value

    def get_field_deserializers(self) -> Dict[str, Callable[[ParseNode], None]]:
        return {
            "myString": lambda n: setattr(self, 'my_string', n.get_str_value()),
            "myInt": lambda n: setattr(self, 'my_int', n.get_int_value())
        }

    def serialize(self, writer: SerializationWriter) -> None:
        writer.write_str_value("myString", self.my_string)
        writer.write_int_value("myInt", self.my_int)
        writer.write_additional_data_value(self.additional_data)

# 2. Instantiate and populate the model
model_to_serialize = MyFormModel()
model_to_serialize.my_string = "Kiota Form Test"
model_to_serialize.my_int = 42
model_to_serialize.additional_data["version"] = "1.0"

# 3. Use FormSerializationWriterFactory to serialize the model
writer_factory = FormSerializationWriterFactory()
writer = writer_factory.get_serialization_writer("application/x-www-form-urlencoded")
writer.write_object_value(None, model_to_serialize)
serialized_content = writer.get_serialized_content()

print(f"Serialized Form Data: {serialized_content.decode('utf-8')}")

# 4. Use FormParseNodeFactory to deserialize the content back into a model
parser_factory = FormParseNodeFactory()
parse_node = parser_factory.get_parse_node("application/x-www-form-urlencoded", serialized_content)

deserialized_model = parse_node.get_object_value(MyFormModel)

print(f"Deserialized my_string: {deserialized_model.my_string}")
print(f"Deserialized my_int: {deserialized_model.my_int}")
print(f"Deserialized additional_data: {deserialized_model.additional_data}")