Create Types for untyped nodes

CHANGELOG.md

@@ -5,6 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+### Added
+
+- Added support for untyped nodes. [#285](https://github.com/microsoft/kiota-abstractions-python/issues/285)
+
+### Changed
 
 ## [1.3.3] - 2024-05-21
 

kiota_abstractions/serialization/untyped_boolean.py

@@ -0,0 +1,26 @@
+from .untyped_node import UntypedNode
+
+class UntypedBoolean(UntypedNode):
+    """
+    Represents an untyped node with boolean value.
+    """
+
+    def __init__(self, value: bool) -> None:
+        """
+        Creates a new instance of UntypedBoolean.
+
+        Args:
+            value (bool): The boolean value associated with the node.
+        """
+        if not isinstance(value, bool):
+            raise TypeError("Value of UntypedBoolean must be of type bool")
+        self.__value = value
+
+    def get_value(self) -> bool:
+        """
+        Gets the value associated with untyped boolean node.
+
+        Returns:
+            The value associated with untyped boolean node.
+        """
+        return self.__value

kiota_abstractions/serialization/untyped_dict.py

@@ -0,0 +1,30 @@
+from .untyped_node import UntypedNode
+
+class UntypedDictionary(UntypedNode):
+    """
+    Represents an untyped node with dictionary value.
+    """
+
+    def __init__(self, value: dict[str:UntypedNode]) -> None:
+        """
+        Creates a new instance of UntypedDictionary.
+
+        Args:
+            value (dict): The key-value pair associated with the node.
+        """
+        if not isinstance(value, dict):
+            if not all(isinstance(key, str) for key in value.keys()):
+                raise TypeError("Keys of UntypedDictionary must be of type str")
+            if not all(isinstance(value, UntypedNode) for value in value.values()):
+                raise TypeError("Values of UntypedDictionary must be of type UntypedNode")
+            raise TypeError("Value of UntypedDictionary must be of type dict")
+        self.__value = value
+
+    def get_value(self) -> dict[str:UntypedNode]:
+        """
+        Gets the value associated with untyped dictionary node.
+
+        Returns:
+            The value associated with untyped dictionary node.
+        """
+        return self.__value

kiota_abstractions/serialization/untyped_float.py

@@ -0,0 +1,26 @@
+from .untyped_node import UntypedNode
+
+class UntypedFloat(UntypedNode):
+    """
+    Represents an untyped node with float value.
+    """
+
+    def __init__(self, value: float) -> None:
+        """
+        Creates a new instance of UntypedFloat.
+
+        Args:
+            value (bool): The float value associated with the node.
+        """
+        if not isinstance(value, float):
+            raise TypeError("Value of UntypedFloat must be of type float")
+        self.__value = value
+
+    def get_value(self) -> float:
+        """
+        Gets the value associated with untyped float node.
+
+        Returns:
+            The value associated with untyped float node.
+        """
+        return self.__value

kiota_abstractions/serialization/untyped_integer.py

@@ -0,0 +1,26 @@
+from .untyped_node import UntypedNode
+
+class UntypedInteger(UntypedNode):
+    """
+    Represents an untyped node with integer value.
+    """
+
+    def __init__(self, value: int) -> None:
+        """
+        Creates a new instance of UntypedInteger.
+
+        Args:
+            value (bool): The integer value associated with the node.
+        """
+        if not isinstance(value, int):
+            raise TypeError("Value of UntypedInteger must be of type int")
+        self.__value = value
+
+    def get_value(self) -> int:
+        """
+        Gets the value associated with untyped integer node.
+
+        Returns:
+            The value associated with untyped integer node.
+        """
+        return self.__value

kiota_abstractions/serialization/untyped_list.py

@@ -0,0 +1,28 @@
+from .untyped_node import UntypedNode
+
+class UntypedList(UntypedNode):
+    """
+    Represents an untyped node with list value.
+    """
+
+    def __init__(self, value: list[UntypedNode]) -> None:
+        """
+        Creates a new instance of UntypedList.
+
+        Args:
+            value (bool): The list value associated with the node.
+        """
+        if not isinstance(value, list):
+            if not all(isinstance(value, UntypedNode) for value in value):
+                raise TypeError("Values of UntypedList must be of type UntypedNode")
+            raise TypeError("Value of UntypedList must be of type list")
+        self.__value = value
+
+    def get_value(self) -> list[UntypedNode]:
+        """
+        Gets the value associated with untyped list node.
+
+        Returns:
+            The value associated with untyped list node.
+        """
+        return self.__value

kiota_abstractions/serialization/untyped_node.py

@@ -0,0 +1,51 @@
+from collections import defaultdict
+from parsable import Parsable
+from typing import TYPE_CHECKING, Callable, Dict
+
+if TYPE_CHECKING:
+    from .parse_node import ParseNode
+    from .serialization_writer import SerializationWriter
+
+class UntypedNode(Parsable):
+    """
+    Base class for untyped node.
+    """
+
+    __field_deserializers: Dict[str, Callable[['ParseNode'], None]] = {}
+
+    def get_field_deserializers(self) -> Dict[str, Callable[['ParseNode'], None]]:
+        """
+        The deserialization information for the current model
+        """
+        return UntypedNode.__field_deserializers
+
+    def serialize(self, writer: 'SerializationWriter'):
+        """
+        Serializes information about the current object.
+
+        Args:
+            writer (SerializationWriter): Serialization writer to use to serialize this model.
+        """
+        if not writer:
+            raise ValueError("writer cannot be None")
+
+    @staticmethod
+    def create_from_discriminator_value(parse_node: 'Parsable'):
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+
+        Args:
+            parse_node (ParseNode): The parse node to use to read the discriminator value and create the object
+        """
+        if not parse_node:
+            raise ValueError("parse_node cannot be None")
+        return UntypedNode()
+
+    def get_value(self):
+        """
+        Gets the value of the current node.
+
+        Returns:
+            The value assigned to untyped node.
+        """
+        raise NotImplementedError("This method is not implemented")

kiota_abstractions/serialization/untyped_none.py

@@ -0,0 +1,15 @@
+from .untyped_node import UntypedNode
+
+class UntypedNone(UntypedNode):
+    """
+    Represents an untyped node with none value.
+    """
+
+    def get_value(self) -> None:
+        """
+        Gets the value associated with untyped none node.
+
+        Returns:
+            The value associated with untyped none node.
+        """
+        return None

kiota_abstractions/serialization/untyped_string.py

@@ -0,0 +1,26 @@
+from .untyped_node import UntypedNode
+
+class UntypedString(UntypedNode):
+    """
+    Represents an untyped node with string value.
+    """
+
+    def __init__(self, value: str) -> None:
+        """
+        Creates a new instance of UntypedStr.
+
+        Args:
+            value (bool): The string value associated with the node.
+        """
+        if not isinstance(value, str):
+            raise TypeError("Value of UntypedStr must be of type str")
+        self.__value = value
+
+    def get_value(self) -> str:
+        """
+        Gets the value associated with untyped string node.
+
+        Returns:
+            The value associated with untyped string node.
+        """
+        return self.__value