refactor: replace if/elif type chains with dispatch dict in get_collection_of_primitive_values

Co-authored-by: baywet <7905502+baywet@users.noreply.github.com>

Author: Copilot

packages/serialization/form/kiota_serialization_form/form_parse_node.py

@@ -120,34 +120,22 @@ def get_collection_of_primitive_values(self, primitive_type: type[T]) -> Optiona
         if not primitive_type:
             raise Exception("Primitive type for deserialization cannot be null")
 
-        primitive_types = {bool, str, int, float, UUID, datetime, timedelta, date, time, bytes}
-        if primitive_type in primitive_types:
-            items = self._node.split(',')
-            result: list[T] = []
-            for item in items:
-                decoded_item = unquote_plus(item)
-                if primitive_type == bool:
-                    result.append(self._get_bool_value(decoded_item))
-                elif primitive_type == str:
-                    result.append(self._get_str_value(decoded_item))
-                elif primitive_type == int:
-                    result.append(self._get_int_value(decoded_item))
-                elif primitive_type == float:
-                    result.append(self._get_float_value(decoded_item))
-                elif primitive_type == UUID:
-                    result.append(self._get_uuid_value(decoded_item))
-                elif primitive_type == datetime:
-                    result.append(self._get_datetime_value(decoded_item))
-                elif primitive_type == timedelta:
-                    result.append(self._get_timedelta_value(decoded_item))
-                elif primitive_type == date:
-                    result.append(self._get_date_value(decoded_item))
-                elif primitive_type == time:
-                    result.append(self._get_time_value(decoded_item))
-                elif primitive_type == bytes:
-                    result.append(self._get_bytes_value(decoded_item))
-            return result
-        raise Exception(f"Encountered an unknown type during deserialization {primitive_type}")
+        converters = {
+            bool: self._get_bool_value,
+            str: self._get_str_value,
+            int: self._get_int_value,
+            float: self._get_float_value,
+            UUID: self._get_uuid_value,
+            datetime: self._get_datetime_value,
+            timedelta: self._get_timedelta_value,
+            date: self._get_date_value,
+            time: self._get_time_value,
+            bytes: self._get_bytes_value,
+        }
+        converter = converters.get(primitive_type)
+        if converter is None:
+            raise Exception(f"Encountered an unknown type during deserialization {primitive_type}")
+        return [converter(unquote_plus(item)) for item in self._node.split(',')]
 
     def get_collection_of_object_values(self, factory: ParsableFactory[U]) -> Optional[list[U]]:
         raise Exception("Collection of object values is not supported with uri form encoding.")

packages/serialization/json/kiota_serialization_json/json_parse_node.py

@@ -118,29 +118,25 @@ def get_collection_of_primitive_values(self, primitive_type: type[T]) -> Optiona
             list[T]: The collection of primitive values
         """
 
+        converters = {
+            bool: self._get_bool_value,
+            str: self._get_str_value,
+            int: self._get_int_value,
+            float: self._get_float_value,
+            UUID: self._get_uuid_value,
+            datetime: self._get_datetime_value,
+            timedelta: self._get_timedelta_value,
+            date: self._get_date_value,
+            time: self._get_time_value,
+            bytes: self._get_bytes_value,
+        }
+
         def func(item):
-            generic_type = primitive_type if primitive_type else type(item)
-            if generic_type == bool:
-                return self._get_bool_value(item)
-            if generic_type == str:
-                return self._get_str_value(item)
-            if generic_type == int:
-                return self._get_int_value(item)
-            if generic_type == float:
-                return self._get_float_value(item)
-            if generic_type == UUID:
-                return self._get_uuid_value(item)
-            if generic_type == datetime:
-                return self._get_datetime_value(item)
-            if generic_type == timedelta:
-                return self._get_timedelta_value(item)
-            if generic_type == date:
-                return self._get_date_value(item)
-            if generic_type == time:
-                return self._get_time_value(item)
-            if generic_type == bytes:
-                return self._get_bytes_value(item)
-            raise Exception(f"Encountered an unknown type during deserialization {generic_type}")
+            t = primitive_type if primitive_type else type(item)
+            converter = converters.get(t)
+            if converter is None:
+                raise Exception(f"Encountered an unknown type during deserialization {t}")
+            return converter(item)
 
         if isinstance(self._json_node, str):
             return list(map(func, json.loads(self._json_node)))