{"id":1552,"library":"microsoft-kiota-serialization-form","title":"Microsoft Kiota Serialization Form","description":"microsoft-kiota-serialization-form is part of the Microsoft Kiota ecosystem, providing a serialization and deserialization factory for `application/x-www-form-urlencoded` content types in Python. It's used by Kiota-generated API clients and custom applications to handle form data. It is currently at version 1.10.1 and follows Kiota's frequent release cadence.","status":"active","version":"1.10.1","language":"en","source_language":"en","source_url":"https://github.com/microsoft/kiota-python","tags":["microsoft","kiota","serialization","form","api client"],"install":[{"cmd":"pip install microsoft-kiota-serialization-form","lang":"bash","label":"Install latest version"}],"dependencies":[{"reason":"This library depends on Kiota's core abstraction layer for defining serialization and parsing interfaces.","package":"microsoft-kiota-abstractions","optional":false}],"imports":[{"symbol":"FormSerializationWriterFactory","correct":"from microsoft_kiota_serialization_form import FormSerializationWriterFactory"},{"symbol":"FormParseNodeFactory","correct":"from microsoft_kiota_serialization_form import FormParseNodeFactory"}],"quickstart":{"code":"from typing import Callable, Dict, Optional\nfrom microsoft_kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter\nfrom microsoft_kiota_serialization_form import FormParseNodeFactory, FormSerializationWriterFactory\n\n# 1. Define a simple model that implements Kiota's Parsable and AdditionalDataHolder\nclass MyFormModel(Parsable, AdditionalDataHolder):\n    def __init__(self) -> None:\n        self._my_string: Optional[str] = None\n        self._my_int: Optional[int] = None\n        self._additional_data: Dict[str, object] = {}\n\n    @property\n    def my_string(self) -> Optional[str]:\n        return self._my_string\n\n    @my_string.setter\n    def my_string(self, value: Optional[str]) -> None:\n        self._my_string = value\n\n    @property\n    def my_int(self) -> Optional[int]:\n        return self._my_int\n\n    @my_int.setter\n    def my_int(self, value: Optional[int]) -> None:\n        self._my_int = value\n\n    @property\n    def additional_data(self) -> Dict[str, object]:\n        return self._additional_data\n\n    @additional_data.setter\n    def additional_data(self, value: Dict[str, object]) -> None:\n        self._additional_data = value\n\n    def get_field_deserializers(self) -> Dict[str, Callable[[ParseNode], None]]:\n        return {\n            \"myString\": lambda n: setattr(self, 'my_string', n.get_str_value()),\n            \"myInt\": lambda n: setattr(self, 'my_int', n.get_int_value())\n        }\n\n    def serialize(self, writer: SerializationWriter) -> None:\n        writer.write_str_value(\"myString\", self.my_string)\n        writer.write_int_value(\"myInt\", self.my_int)\n        writer.write_additional_data_value(self.additional_data)\n\n# 2. Instantiate and populate the model\nmodel_to_serialize = MyFormModel()\nmodel_to_serialize.my_string = \"Kiota Form Test\"\nmodel_to_serialize.my_int = 42\nmodel_to_serialize.additional_data[\"version\"] = \"1.0\"\n\n# 3. Use FormSerializationWriterFactory to serialize the model\nwriter_factory = FormSerializationWriterFactory()\nwriter = writer_factory.get_serialization_writer(\"application/x-www-form-urlencoded\")\nwriter.write_object_value(None, model_to_serialize)\nserialized_content = writer.get_serialized_content()\n\nprint(f\"Serialized Form Data: {serialized_content.decode('utf-8')}\")\n\n# 4. Use FormParseNodeFactory to deserialize the content back into a model\nparser_factory = FormParseNodeFactory()\nparse_node = parser_factory.get_parse_node(\"application/x-www-form-urlencoded\", serialized_content)\n\ndeserialized_model = parse_node.get_object_value(MyFormModel)\n\nprint(f\"Deserialized my_string: {deserialized_model.my_string}\")\nprint(f\"Deserialized my_int: {deserialized_model.my_int}\")\nprint(f\"Deserialized additional_data: {deserialized_model.additional_data}\")","lang":"python","description":"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."},"warnings":[{"fix":"Upgrade your Python environment to 3.10 or newer (up to <4.0).","message":"Support for Python 3.9 was dropped in version 1.10.0 across all Kiota Python libraries.","severity":"breaking","affected_versions":">=1.10.0"},{"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.","message":"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`).","severity":"gotcha","affected_versions":"All"},{"fix":"Carefully define your data models to adhere to the `Parsable` interface, including mapping fields to their deserializer functions and implementing the `serialize` method.","message":"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.","severity":"gotcha","affected_versions":"All"}],"env_vars":null,"last_verified":"2026-04-09T00:00:00.000Z","next_check":"2026-07-08T00:00:00.000Z"}