From 91397589c8f8787adb06babd5f0970747766bf55 Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Tue, 14 Jan 2025 17:15:29 +0100
Subject: [PATCH 01/24] Remove pendulum dependency

Fixes #448

Remove the `pendulum` dependency and replace it with equivalent BCL/abstractions methods.

* **Add `parseTimeDeltaFromIsoFormat` function**:
  - Implement a static function `parseTimeDeltaFromIsoFormat` in `packages/abstractions/kiota_abstractions/utils.py` to parse ISO 8601 duration strings.
  - Add import for `re` module.

* **Replace `pendulum` calls**:
  - Replace `pendulum.parse` calls with equivalent BCL/abstractions methods in `packages/serialization/form/kiota_serialization_form/form_parse_node.py`.
  - Replace `pendulum.parse` calls with equivalent BCL/abstractions methods in `packages/serialization/json/kiota_serialization_json/json_parse_node.py`.

* **Remove `pendulum` dependency**:
  - Remove `pendulum` dependency from `packages/serialization/form/pyproject.toml`.
  - Remove `pendulum` dependency from `packages/serialization/json/pyproject.toml`.

---

For more details, open the [Copilot Workspace session](https://copilot-workspace.githubnext.com/microsoft/kiota-python/issues/448?shareId=XXXX-XXXX-XXXX-XXXX).
---
 .../abstractions/kiota_abstractions/utils.py  | 34 ++++++++++++++++-
 .../form_parse_node.py                        | 38 +++++++++----------
 packages/serialization/form/pyproject.toml    |  3 +-
 .../json_parse_node.py                        | 37 +++++++++++-------
 packages/serialization/json/pyproject.toml    |  1 -
 5 files changed, 76 insertions(+), 37 deletions(-)

diff --git a/packages/abstractions/kiota_abstractions/utils.py b/packages/abstractions/kiota_abstractions/utils.py
index 6e01b84..9bde86b 100644
--- a/packages/abstractions/kiota_abstractions/utils.py
+++ b/packages/abstractions/kiota_abstractions/utils.py
@@ -1,6 +1,7 @@
 import importlib.util
 import sys
-
+import re
+from datetime import timedelta
 
 def lazy_import(name):
     """Lazily imports a python module given its absolute path.
@@ -37,3 +38,34 @@ def lazy_import(name):
     loader.exec_module(module)
 
     return module
+
+def parseTimeDeltaFromIsoFormat(duration_str):
+    """Parses an ISO 8601 duration string into a timedelta object.
+
+    Args:
+        duration_str (str): The ISO 8601 duration string.
+
+    Returns:
+        timedelta: The parsed timedelta object.
+    """
+    pattern = re.compile(
+        r'P'  # starts with 'P'
+        r'(?:(\d+)Y)?'  # years
+        r'(?:(\d+)M)?'  # months
+        r'(?:(\d+)D)?'  # days
+        r'(?:T'  # time part starts with 'T'
+        r'(?:(\d+)H)?'  # hours
+        r'(?:(\d+)M)?'  # minutes
+        r'(?:(\d+)S)?)?'  # seconds
+    )
+    match = pattern.fullmatch(duration_str)
+    if not match:
+        raise ValueError(f"Invalid ISO 8601 duration string: {duration_str}")
+
+    years, months, days, hours, minutes, seconds = match.groups()
+    return timedelta(
+        days=int(days or 0) + int(years or 0) * 365 + int(months or 0) * 30,
+        hours=int(hours or 0),
+        minutes=int(minutes or 0),
+        seconds=int(seconds or 0)
+    )
diff --git a/packages/serialization/form/kiota_serialization_form/form_parse_node.py b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
index f9c73cb..b5d75b8 100644
--- a/packages/serialization/form/kiota_serialization_form/form_parse_node.py
+++ b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
@@ -9,7 +9,7 @@
 from urllib.parse import unquote_plus
 from uuid import UUID
 
-import pendulum
+from kiota_abstractions.utils import parseTimeDeltaFromIsoFormat
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
@@ -93,10 +93,7 @@ def get_datetime_value(self) -> Optional[datetime]:
         """
         if self._node and self._node != "null":
             try:
-                datetime_obj = pendulum.parse(self._node, exact=True)
-                if isinstance(datetime_obj, pendulum.DateTime):
-                    return datetime_obj
-                return None
+                return datetime.fromisoformat(self._node)
             except:
                 return None
         return None
@@ -108,10 +105,7 @@ def get_timedelta_value(self) -> Optional[timedelta]:
         """
         if self._node and self._node != "null":
             try:
-                datetime_obj = pendulum.parse(self._node, exact=True)
-                if isinstance(datetime_obj, pendulum.Duration):
-                    return datetime_obj.as_timedelta()
-                return None
+                return parseTimeDeltaFromIsoFormat(self._node)
             except:
                 return None
         return None
@@ -123,10 +117,7 @@ def get_date_value(self) -> Optional[date]:
         """
         if self._node and self._node != "null":
             try:
-                datetime_obj = pendulum.parse(self._node, exact=True)
-                if isinstance(datetime_obj, pendulum.Date):
-                    return datetime_obj
-                return None
+                return date.fromisoformat(self._node)
             except:
                 return None
         return None
@@ -138,10 +129,7 @@ def get_time_value(self) -> Optional[time]:
         """
         if self._node and self._node != "null":
             try:
-                datetime_obj = pendulum.parse(self._node, exact=True)
-                if isinstance(datetime_obj, pendulum.Time):
-                    return datetime_obj
-                return None
+                return time.fromisoformat(self._node)
             except:
                 return None
         return None
@@ -315,9 +303,7 @@ def try_get_anything(self, value: Any) -> Any:
             return dict(map(lambda x: (x[0], self.try_get_anything(x[1])), value.items()))
         if isinstance(value, str):
             try:
-                datetime_obj = pendulum.parse(value)
-                if isinstance(datetime_obj, pendulum.Duration):
-                    return datetime_obj.as_timedelta()
+                datetime_obj = datetime.fromisoformat(value)
                 return datetime_obj
             except ValueError:
                 pass
@@ -325,6 +311,18 @@ def try_get_anything(self, value: Any) -> Any:
                 return UUID(value)
             except ValueError:
                 pass
+            try:
+                return parseTimeDeltaFromIsoFormat(value)
+            except ValueError:
+                pass
+            try:
+                return date.fromisoformat(value)
+            except ValueError:
+                pass
+            try:
+                return time.fromisoformat(value)
+            except ValueError:
+                pass
             return value
         raise ValueError(f"Unexpected additional value type {type(value)} during deserialization.")
 
diff --git a/packages/serialization/form/pyproject.toml b/packages/serialization/form/pyproject.toml
index c57b32c..e096d1c 100644
--- a/packages/serialization/form/pyproject.toml
+++ b/packages/serialization/form/pyproject.toml
@@ -25,7 +25,6 @@ packages = [{include = "kiota_serialization_form"}]
 [tool.poetry.dependencies]
 python = ">=3.9,<4.0"
 microsoft-kiota-abstractions = {path="../../abstractions/", develop=true}
-pendulum = ">=3.0.0b1"
 
 [tool.poetry.group.dev.dependencies]
 yapf = ">=0.40.2,<0.44.0"
@@ -52,4 +51,4 @@ profile = "hug"
 
 [tool.poetry-monorepo.deps]
 enabled = true
-commands = ["build", "export", "publish"]
\ No newline at end of file
+commands = ["build", "export", "publish"]
diff --git a/packages/serialization/json/kiota_serialization_json/json_parse_node.py b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
index 1242c9c..ef994a8 100644
--- a/packages/serialization/json/kiota_serialization_json/json_parse_node.py
+++ b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
@@ -9,7 +9,7 @@
 from typing import Any, Optional, TypeVar
 from uuid import UUID
 
-import pendulum
+from kiota_abstractions.utils import parseTimeDeltaFromIsoFormat
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
@@ -96,8 +96,8 @@ def get_datetime_value(self) -> Optional[datetime]:
             if len(self._json_node) < 10:
                 return None
 
-            datetime_obj = pendulum.parse(self._json_node, exact=True)
-            if isinstance(datetime_obj, pendulum.DateTime):
+            datetime_obj = datetime.fromisoformat(self._json_node)
+            if isinstance(datetime_obj, datetime):
                 return datetime_obj
         return None
 
@@ -109,9 +109,10 @@ def get_timedelta_value(self) -> Optional[timedelta]:
         if isinstance(self._json_node, timedelta):
             return self._json_node
         if isinstance(self._json_node, str):
-            datetime_obj = pendulum.parse(self._json_node, exact=True)
-            if isinstance(datetime_obj, pendulum.Duration):
-                return datetime_obj.as_timedelta()
+            try:
+                return parseTimeDeltaFromIsoFormat(self._json_node)
+            except ValueError:
+                return None
         return None
 
     def get_date_value(self) -> Optional[date]:
@@ -122,8 +123,8 @@ def get_date_value(self) -> Optional[date]:
         if isinstance(self._json_node, date):
             return self._json_node
         if isinstance(self._json_node, str):
-            datetime_obj = pendulum.parse(self._json_node, exact=True)
-            if isinstance(datetime_obj, pendulum.Date):
+            datetime_obj = date.fromisoformat(self._json_node)
+            if isinstance(datetime_obj, date):
                 return datetime_obj
         return None
 
@@ -135,8 +136,8 @@ def get_time_value(self) -> Optional[time]:
         if isinstance(self._json_node, time):
             return self._json_node
         if isinstance(self._json_node, str):
-            datetime_obj = pendulum.parse(self._json_node, exact=True)
-            if isinstance(datetime_obj, pendulum.Time):
+            datetime_obj = time.fromisoformat(self._json_node)
+            if isinstance(datetime_obj, time):
                 return datetime_obj
         return None
 
@@ -315,9 +316,7 @@ def try_get_anything(self, value: Any) -> Any:
                     return value
                 if value.isdigit():
                     return value
-                datetime_obj = pendulum.parse(value)
-                if isinstance(datetime_obj, pendulum.Duration):
-                    return datetime_obj.as_timedelta()
+                datetime_obj = datetime.fromisoformat(value)
                 return datetime_obj
             except ValueError:
                 pass
@@ -325,6 +324,18 @@ def try_get_anything(self, value: Any) -> Any:
                 return UUID(value)
             except:
                 pass
+            try:
+                return parseTimeDeltaFromIsoFormat(value)
+            except ValueError:
+                pass
+            try:
+                return date.fromisoformat(value)
+            except ValueError:
+                pass
+            try:
+                return time.fromisoformat(value)
+            except ValueError:
+                pass
             return value
         raise ValueError(f"Unexpected additional value type {type(value)} during deserialization.")
 
diff --git a/packages/serialization/json/pyproject.toml b/packages/serialization/json/pyproject.toml
index 82e7453..957ebf4 100644
--- a/packages/serialization/json/pyproject.toml
+++ b/packages/serialization/json/pyproject.toml
@@ -25,7 +25,6 @@ packages = [{include = "kiota_serialization_json"}]
 [tool.poetry.dependencies]
 python = ">=3.9,<4.0"
 microsoft-kiota-abstractions = {path="../../abstractions/", develop=true}
-pendulum = ">=3.0.0b1"
 
 [tool.poetry.group.dev.dependencies]
 yapf = ">=0.40.2,<0.44.0"

From 41d8efd3a9e3fe62304cb1703573e898b476d9a8 Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Wed, 15 Jan 2025 09:29:37 +0000
Subject: [PATCH 02/24] Feedback processed and removed python-dateutil

---
 .../abstractions/kiota_abstractions/utils.py  | 39 ++++++++++++------
 packages/abstractions/tests/test_utils.py     | 41 +++++++++++++++++++
 .../json/tests/unit/test_json_parse_node.py   |  4 +-
 .../text_parse_node.py                        | 16 +++-----
 packages/serialization/text/pyproject.toml    |  2 -
 5 files changed, 75 insertions(+), 27 deletions(-)
 create mode 100644 packages/abstractions/tests/test_utils.py

diff --git a/packages/abstractions/kiota_abstractions/utils.py b/packages/abstractions/kiota_abstractions/utils.py
index 9bde86b..4c84c67 100644
--- a/packages/abstractions/kiota_abstractions/utils.py
+++ b/packages/abstractions/kiota_abstractions/utils.py
@@ -39,32 +39,47 @@ def lazy_import(name):
 
     return module
 
-def parseTimeDeltaFromIsoFormat(duration_str):
-    """Parses an ISO 8601 duration string into a timedelta object.
-
-    Args:
-        duration_str (str): The ISO 8601 duration string.
-
-    Returns:
-        timedelta: The parsed timedelta object.
-    """
-    pattern = re.compile(
+# https://en.wikipedia.org/wiki/ISO_8601#Durations
+# PnYnMnDTnHnMnS
+# PnW
+# P<date>T<time>
+_ISO8601_DURATION_PATTERN = re.compile(
         r'P'  # starts with 'P'
         r'(?:(\d+)Y)?'  # years
         r'(?:(\d+)M)?'  # months
+        r'(?:(\d+)W)?'  # weeks
         r'(?:(\d+)D)?'  # days
         r'(?:T'  # time part starts with 'T'
         r'(?:(\d+)H)?'  # hours
         r'(?:(\d+)M)?'  # minutes
         r'(?:(\d+)S)?)?'  # seconds
     )
+
+def parseTimeDeltaFromIsoFormat(duration_str):
+    """Parses an ISO 8601 duration string into a timedelta object.
+
+    https://en.wikipedia.org/wiki/ISO_8601#Durations
+    PnYnMnDTnHnMnS (where n is a number, supported)
+    PnW (weeks, supported)
+    P<date>T<time> (not implemented)
+
+    Args:
+        duration_str (str): The ISO 8601 duration string.
+
+    Returns:
+        timedelta: The parsed timedelta object.
+    """
+    pattern = _ISO8601_DURATION_PATTERN
     match = pattern.fullmatch(duration_str)
     if not match:
         raise ValueError(f"Invalid ISO 8601 duration string: {duration_str}")
 
-    years, months, days, hours, minutes, seconds = match.groups()
+    years, months, weeks, days, hours, minutes, seconds = match.groups()
     return timedelta(
-        days=int(days or 0) + int(years or 0) * 365 + int(months or 0) * 30,
+        years=int(years or 0),
+        months=int(months or 0),
+        weeks=int(weeks or 0),
+        days=int(days or 0),
         hours=int(hours or 0),
         minutes=int(minutes or 0),
         seconds=int(seconds or 0)
diff --git a/packages/abstractions/tests/test_utils.py b/packages/abstractions/tests/test_utils.py
new file mode 100644
index 0000000..2cae8e9
--- /dev/null
+++ b/packages/abstractions/tests/test_utils.py
@@ -0,0 +1,41 @@
+import pytest
+
+from kiota_abstractions.utils import parseTimeDeltaFromIsoFormat
+
+def test_parseTimeDeltaFromIsoFormat_weeks():
+    result = parseTimeDeltaFromIsoFormat("P3W")
+    assert result.days == 21
+
+def test_parseTimeDeltaFromIsoFormat_days():
+    result = parseTimeDeltaFromIsoFormat("P3D")
+    assert result.days == 3
+
+def test_parseTimeDeltaFromIsoFormat_hours():
+    result = parseTimeDeltaFromIsoFormat("PT3H")
+    assert result.seconds == 10800
+
+def test_parseTimeDeltaFromIsoFormat_minutes():
+    result = parseTimeDeltaFromIsoFormat("PT3M")
+    assert result.seconds == 180
+
+def test_parseTimeDeltaFromIsoFormat_seconds():
+    result = parseTimeDeltaFromIsoFormat("PT3S")
+    assert result.seconds == 3
+
+def test_parseTimeDeltaFromIsoFormat_years():
+    result = parseTimeDeltaFromIsoFormat("P3Y")
+    assert result.days == 1095
+
+def test_parseTimeDeltaFromIsoFormat_months():
+    result = parseTimeDeltaFromIsoFormat("P3M")
+    assert result.days == 90
+
+# This is "invalid" according to the ISO 8601 standard, but python also supports it
+def test_parseTimeDeltaFromIsoFormat_weeks_and_years():
+    result = parseTimeDeltaFromIsoFormat("P3Y3W")
+    assert result.days == 1122
+
+def test_parseTimeDeltaFromIsoFormat_days_and_time():
+    result = parseTimeDeltaFromIsoFormat("P3DT3H3M3S")
+    assert result.days == 3
+    assert result.seconds == 10983
diff --git a/packages/serialization/json/tests/unit/test_json_parse_node.py b/packages/serialization/json/tests/unit/test_json_parse_node.py
index 965bc8a..8e0ce45 100644
--- a/packages/serialization/json/tests/unit/test_json_parse_node.py
+++ b/packages/serialization/json/tests/unit/test_json_parse_node.py
@@ -161,8 +161,8 @@ def test_get_anythin_does_not_convert_any_length_numeric_chars_to_datetime():
 def test_get_anythin_does_convert_date_string_to_datetime():
     parse_node = JsonParseNode("2023-10-05T14:48:00.000Z")
     result = parse_node.try_get_anything("2023-10-05T14:48:00.000Z")
-    assert isinstance(result, pendulum.DateTime)
-    assert result == pendulum.parse("2023-10-05T14:48:00.000Z")
+    assert isinstance(result, datetime)
+    assert result == datetime.fromisoformat("2023-10-05T14:48:00.000Z")
 
 
 def test_get_object_value(user1_json):
diff --git a/packages/serialization/text/kiota_serialization_text/text_parse_node.py b/packages/serialization/text/kiota_serialization_text/text_parse_node.py
index 0a61a67..5c76c95 100644
--- a/packages/serialization/text/kiota_serialization_text/text_parse_node.py
+++ b/packages/serialization/text/kiota_serialization_text/text_parse_node.py
@@ -7,7 +7,7 @@
 from typing import Optional, TypeVar
 from uuid import UUID
 
-from dateutil import parser
+from kiota_abstractions.utils import parseTimeDeltaFromIsoFormat
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
@@ -95,8 +95,7 @@ def get_datetime_value(self) -> Optional[datetime]:
         """
         datetime_str = self.get_str_value()
         if datetime_str:
-            datetime_obj = parser.parse(datetime_str)
-            return datetime_obj
+            return datetime.fromisoformat(datetime_str)
         return None
 
     def get_timedelta_value(self) -> Optional[timedelta]:
@@ -106,10 +105,7 @@ def get_timedelta_value(self) -> Optional[timedelta]:
         """
         datetime_str = self.get_str_value()
         if datetime_str:
-            datetime_obj = parser.parse(datetime_str)
-            return timedelta(
-                hours=datetime_obj.hour, minutes=datetime_obj.minute, seconds=datetime_obj.second
-            )
+            return parseTimeDeltaFromIsoFormat(datetime_str)
         return None
 
     def get_date_value(self) -> Optional[date]:
@@ -119,8 +115,7 @@ def get_date_value(self) -> Optional[date]:
         """
         datetime_str = self.get_str_value()
         if datetime_str:
-            datetime_obj = parser.parse(datetime_str)
-            return datetime_obj.date()
+            return date.fromisoformat(datetime_str)
         return None
 
     def get_time_value(self) -> Optional[time]:
@@ -130,8 +125,7 @@ def get_time_value(self) -> Optional[time]:
         """
         datetime_str = self.get_str_value()
         if datetime_str:
-            datetime_obj = parser.parse(datetime_str)
-            return datetime_obj.time()
+            return time.fromisoformat(datetime_str)
         return None
 
     def get_collection_of_primitive_values(self, primitive_type: type[T]) -> list[T]:
diff --git a/packages/serialization/text/pyproject.toml b/packages/serialization/text/pyproject.toml
index 91982cf..1c27656 100644
--- a/packages/serialization/text/pyproject.toml
+++ b/packages/serialization/text/pyproject.toml
@@ -25,7 +25,6 @@ packages = [{include = "kiota_serialization_text"}]
 [tool.poetry.dependencies]
 python = ">=3.9,<4.0"
 microsoft-kiota-abstractions = {path="../../abstractions/", develop=true}
-python-dateutil = "2.9.0.post0"
 
 [tool.poetry.group.dev.dependencies]
 yapf = ">=0.40.2,<0.44.0"
@@ -35,7 +34,6 @@ mypy = "^1.11.2"
 pytest = "^8.3.2"
 pytest-asyncio = ">=0.24,<0.26"
 poetry-plugin-mono-repo-deps = ">=0.2.1,<0.4.0"
-types-python-dateutil = "^2.9.0.20240906"
 
 [tool.mypy]
 warn_unused_configs = true

From fc6c7190ad3f8ccf7d7d320305c0659455f1b6cf Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Wed, 15 Jan 2025 10:04:15 +0000
Subject: [PATCH 03/24] Some linting

---
 .../abstractions/kiota_abstractions/utils.py  | 23 ++++++------
 packages/abstractions/tests/test_utils.py     | 10 ++++++
 .../form_parse_node.py                        | 36 ++++++++++++-------
 .../json_parse_node.py                        | 30 ++++++++++------
 4 files changed, 67 insertions(+), 32 deletions(-)

diff --git a/packages/abstractions/kiota_abstractions/utils.py b/packages/abstractions/kiota_abstractions/utils.py
index 4c84c67..9e8f3fe 100644
--- a/packages/abstractions/kiota_abstractions/utils.py
+++ b/packages/abstractions/kiota_abstractions/utils.py
@@ -3,6 +3,7 @@
 import re
 from datetime import timedelta
 
+
 def lazy_import(name):
     """Lazily imports a python module given its absolute path.
 
@@ -39,21 +40,23 @@ def lazy_import(name):
 
     return module
 
+
 # https://en.wikipedia.org/wiki/ISO_8601#Durations
 # PnYnMnDTnHnMnS
 # PnW
 # P<date>T<time>
 _ISO8601_DURATION_PATTERN = re.compile(
-        r'P'  # starts with 'P'
-        r'(?:(\d+)Y)?'  # years
-        r'(?:(\d+)M)?'  # months
-        r'(?:(\d+)W)?'  # weeks
-        r'(?:(\d+)D)?'  # days
-        r'(?:T'  # time part starts with 'T'
-        r'(?:(\d+)H)?'  # hours
-        r'(?:(\d+)M)?'  # minutes
-        r'(?:(\d+)S)?)?'  # seconds
-    )
+    r'P'  # starts with 'P'
+    r'(?:(\d+)Y)?'  # years
+    r'(?:(\d+)M)?'  # months
+    r'(?:(\d+)W)?'  # weeks
+    r'(?:(\d+)D)?'  # days
+    r'(?:T'  # time part starts with 'T'
+    r'(?:(\d+)H)?'  # hours
+    r'(?:(\d+)M)?'  # minutes
+    r'(?:(\d+)S)?)?'  # seconds
+)
+
 
 def parseTimeDeltaFromIsoFormat(duration_str):
     """Parses an ISO 8601 duration string into a timedelta object.
diff --git a/packages/abstractions/tests/test_utils.py b/packages/abstractions/tests/test_utils.py
index 2cae8e9..0b617ee 100644
--- a/packages/abstractions/tests/test_utils.py
+++ b/packages/abstractions/tests/test_utils.py
@@ -2,39 +2,49 @@
 
 from kiota_abstractions.utils import parseTimeDeltaFromIsoFormat
 
+
 def test_parseTimeDeltaFromIsoFormat_weeks():
     result = parseTimeDeltaFromIsoFormat("P3W")
     assert result.days == 21
 
+
 def test_parseTimeDeltaFromIsoFormat_days():
     result = parseTimeDeltaFromIsoFormat("P3D")
     assert result.days == 3
 
+
 def test_parseTimeDeltaFromIsoFormat_hours():
     result = parseTimeDeltaFromIsoFormat("PT3H")
     assert result.seconds == 10800
 
+
 def test_parseTimeDeltaFromIsoFormat_minutes():
     result = parseTimeDeltaFromIsoFormat("PT3M")
     assert result.seconds == 180
 
+
 def test_parseTimeDeltaFromIsoFormat_seconds():
     result = parseTimeDeltaFromIsoFormat("PT3S")
     assert result.seconds == 3
 
+
 def test_parseTimeDeltaFromIsoFormat_years():
     result = parseTimeDeltaFromIsoFormat("P3Y")
     assert result.days == 1095
 
+
 def test_parseTimeDeltaFromIsoFormat_months():
     result = parseTimeDeltaFromIsoFormat("P3M")
     assert result.days == 90
 
 # This is "invalid" according to the ISO 8601 standard, but python also supports it
+
+
 def test_parseTimeDeltaFromIsoFormat_weeks_and_years():
     result = parseTimeDeltaFromIsoFormat("P3Y3W")
     assert result.days == 1122
 
+
 def test_parseTimeDeltaFromIsoFormat_days_and_time():
     result = parseTimeDeltaFromIsoFormat("P3DT3H3M3S")
     assert result.days == 3
diff --git a/packages/serialization/form/kiota_serialization_form/form_parse_node.py b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
index b5d75b8..0e855f0 100644
--- a/packages/serialization/form/kiota_serialization_form/form_parse_node.py
+++ b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
@@ -12,7 +12,8 @@
 from kiota_abstractions.utils import parseTimeDeltaFromIsoFormat
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
-T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
+T = TypeVar("T", bool, str, int, float, UUID,
+            datetime, timedelta, date, time, bytes)
 
 U = TypeVar("U", bound=Parsable)
 
@@ -26,8 +27,10 @@ def __init__(self, raw_value: str) -> None:
         self._raw_value = raw_value
         self._node = unquote_plus(raw_value)
         self._fields = self._get_fields(raw_value)
-        self._on_before_assign_field_values: Optional[Callable[[Parsable], None]] = None
-        self._on_after_assign_field_values: Optional[Callable[[Parsable], None]] = None
+        self._on_before_assign_field_values: Optional[Callable[[
+            Parsable], None]] = None
+        self._on_after_assign_field_values: Optional[Callable[[
+            Parsable], None]] = None
 
     def get_str_value(self) -> Optional[str]:
         """Gets the string value from the node
@@ -164,9 +167,11 @@ def get_collection_of_primitive_values(self, primitive_type: type[T]) -> Optiona
             list[T]: The collection of primitive values
         """
         if not primitive_type:
-            raise Exception("Primitive type for deserialization cannot be null")
+            raise Exception(
+                "Primitive type for deserialization cannot be null")
 
-        primitive_types = {bool, str, int, float, UUID, datetime, timedelta, date, time, bytes}
+        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] = []
@@ -176,10 +181,12 @@ def get_collection_of_primitive_values(self, primitive_type: type[T]) -> Optiona
                 method = getattr(current_parse_node, method_name)
                 result.append(method())
             return result
-        raise Exception(f"Encountered an unknown type during deserialization {primitive_type}")
+        raise Exception(f"Encountered an unknown type during deserialization {
+                        primitive_type}")
 
     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.")
+        raise Exception(
+            "Collection of object values is not supported with uri form encoding.")
 
     def get_collection_of_enum_values(self, enum_class: K) -> Optional[list[K]]:
         """Gets the collection of enum values of the node
@@ -190,7 +197,8 @@ def get_collection_of_enum_values(self, enum_class: K) -> Optional[list[K]]:
         if values:
             return list(
                 map(
-                    lambda x: self._create_new_node(x).get_enum_value(enum_class),  # type: ignore
+                    lambda x: self._create_new_node(
+                        x).get_enum_value(enum_class),  # type: ignore
                     values
                 )
             )
@@ -209,11 +217,13 @@ def get_enum_value(self, enum_class: K) -> Optional[K]:
             return enum_class(self._node)  # type: ignore
         values = self._node.split(',')
         if not len(values) > 1:
-            raise Exception(f'Invalid value: {self._node} for enum {enum_class}.')
+            raise Exception(f'Invalid value: {
+                            self._node} for enum {enum_class}.')
         result = []
         for value in values:
             if value not in enum_values:
-                raise Exception(f'Invalid value: {value} for enum {enum_class}.')
+                raise Exception(f'Invalid value: {
+                                value} for enum {enum_class}.')
             result.append(enum_class(value))  # type: ignore
         return result  # type: ignore
 
@@ -287,7 +297,8 @@ def _assign_field_values(self, item: Parsable) -> None:
                 field_deserializer = field_deserializers[field_name]
                 field_deserializer(FormParseNode(field_value))
             elif item_additional_data is not None:
-                item_additional_data[field_name] = self.try_get_anything(field_value)
+                item_additional_data[field_name] = self.try_get_anything(
+                    field_value)
             else:
                 warnings.warn(
                     f"Found additional property {field_name} to \
@@ -324,7 +335,8 @@ def try_get_anything(self, value: Any) -> Any:
             except ValueError:
                 pass
             return value
-        raise ValueError(f"Unexpected additional value type {type(value)} during deserialization.")
+        raise ValueError(f"Unexpected additional value type {
+                         type(value)} during deserialization.")
 
     def _create_new_node(self, node: Any) -> FormParseNode:
         new_node: FormParseNode = FormParseNode(node)
diff --git a/packages/serialization/json/kiota_serialization_json/json_parse_node.py b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
index ef994a8..35fa557 100644
--- a/packages/serialization/json/kiota_serialization_json/json_parse_node.py
+++ b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
@@ -12,7 +12,8 @@
 from kiota_abstractions.utils import parseTimeDeltaFromIsoFormat
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
-T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
+T = TypeVar("T", bool, str, int, float, UUID,
+            datetime, timedelta, date, time, bytes)
 
 U = TypeVar("U", bound=Parsable)
 
@@ -28,8 +29,10 @@ def __init__(self, node: Any) -> None:
                 to initialize the node with
         """
         self._json_node = node
-        self._on_before_assign_field_values: Optional[Callable[[Parsable], None]] = None
-        self._on_after_assign_field_values: Optional[Callable[[Parsable], None]] = None
+        self._on_before_assign_field_values: Optional[Callable[[
+            Parsable], None]] = None
+        self._on_after_assign_field_values: Optional[Callable[[
+            Parsable], None]] = None
 
     def get_child_node(self, identifier: str) -> Optional[ParseNode]:
         """Gets a new parse node for the given identifier
@@ -149,15 +152,18 @@ def get_collection_of_primitive_values(self, primitive_type: type[T]) -> Optiona
             list[T]: The collection of primitive values
         """
 
-        primitive_types = {bool, str, int, float, UUID, datetime, timedelta, date, time, bytes}
+        primitive_types = {bool, str, int, float, UUID,
+                           datetime, timedelta, date, time, bytes}
 
         def func(item):
             generic_type = primitive_type if primitive_type else type(item)
             current_parse_node = self._create_new_node(item)
             if generic_type in primitive_types:
-                method = getattr(current_parse_node, f'get_{generic_type.__name__.lower()}_value')
+                method = getattr(current_parse_node, f'get_{
+                                 generic_type.__name__.lower()}_value')
                 return method()
-            raise Exception(f"Encountered an unknown type during deserialization {generic_type}")
+            raise Exception(
+                f"Encountered an unknown type during deserialization {generic_type}")
 
         if isinstance(self._json_node, str):
             return list(map(func, json.loads(self._json_node)))
@@ -171,7 +177,8 @@ def get_collection_of_object_values(self, factory: ParsableFactory[U]) -> Option
         if isinstance(self._json_node, list):
             return list(
                 map(
-                    lambda x: self._create_new_node(x).get_object_value(factory),  # type: ignore
+                    lambda x: self._create_new_node(
+                        x).get_object_value(factory),  # type: ignore
                     self._json_node,
                 )
             )
@@ -185,7 +192,8 @@ def get_collection_of_enum_values(self, enum_class: K) -> Optional[list[K]]:
         if isinstance(self._json_node, list):
             return list(
                 map(
-                    lambda x: self._create_new_node(x).get_enum_value(enum_class),  # type: ignore
+                    lambda x: self._create_new_node(
+                        x).get_enum_value(enum_class),  # type: ignore
                     self._json_node
                 )
             )
@@ -292,7 +300,8 @@ def _assign_field_values(self, item: Parsable) -> None:
                 field_deserializer = field_deserializers[field_name]
                 field_deserializer(JsonParseNode(field_value))
             elif item_additional_data is not None:
-                item_additional_data[field_name] = self.try_get_anything(field_value)
+                item_additional_data[field_name] = self.try_get_anything(
+                    field_value)
             else:
                 warnings.warn(
                     f"Found additional property {field_name} to \
@@ -337,7 +346,8 @@ def try_get_anything(self, value: Any) -> Any:
             except ValueError:
                 pass
             return value
-        raise ValueError(f"Unexpected additional value type {type(value)} during deserialization.")
+        raise ValueError(f"Unexpected additional value type {
+                         type(value)} during deserialization.")
 
     def _create_new_node(self, node: Any) -> JsonParseNode:
         new_node: JsonParseNode = JsonParseNode(node)

From 431b03642ff878ebd66b3a055c98ec2d7443d6a6 Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Wed, 15 Jan 2025 13:41:13 +0000
Subject: [PATCH 04/24] parse_timedelta acts exacty the same as previous
 library

---
 .../abstractions/kiota_abstractions/utils.py  | 79 ++++++++++---------
 packages/abstractions/tests/test_utils.py     | 51 ++++++------
 .../form_parse_node.py                        |  6 +-
 .../json_parse_node.py                        |  6 +-
 .../text_parse_node.py                        |  4 +-
 5 files changed, 78 insertions(+), 68 deletions(-)

diff --git a/packages/abstractions/kiota_abstractions/utils.py b/packages/abstractions/kiota_abstractions/utils.py
index 9e8f3fe..128a9b0 100644
--- a/packages/abstractions/kiota_abstractions/utils.py
+++ b/packages/abstractions/kiota_abstractions/utils.py
@@ -41,49 +41,54 @@ def lazy_import(name):
     return module
 
 
-# https://en.wikipedia.org/wiki/ISO_8601#Durations
-# PnYnMnDTnHnMnS
-# PnW
-# P<date>T<time>
 _ISO8601_DURATION_PATTERN = re.compile(
-    r'P'  # starts with 'P'
-    r'(?:(\d+)Y)?'  # years
-    r'(?:(\d+)M)?'  # months
-    r'(?:(\d+)W)?'  # weeks
-    r'(?:(\d+)D)?'  # days
-    r'(?:T'  # time part starts with 'T'
-    r'(?:(\d+)H)?'  # hours
-    r'(?:(\d+)M)?'  # minutes
-    r'(?:(\d+)S)?)?'  # seconds
+    "^P"  # Duration P indicator
+    # Weeks
+    "(?P<w>"
+    r"    (?P<weeks>\d+(?:[.,]\d+)?W)"
+    ")?"
+    # Years, Months, Days
+    "(?P<ymd>"
+    r"    (?P<years>\d+(?:[.,]\d+)?Y)?"
+    r"    (?P<months>\d+(?:[.,]\d+)?M)?"
+    r"    (?P<days>\d+(?:[.,]\d+)?D)?"
+    ")?"
+    # Time
+    "(?P<hms>"
+    "    (?P<timesep>T)"  # Separator (T)
+    r"    (?P<hours>\d+(?:[.,]\d+)?H)?"
+    r"    (?P<minutes>\d+(?:[.,]\d+)?M)?"
+    r"    (?P<seconds>\d+(?:[.,]\d+)?S)?"
+    ")?"
+    "$",
+    re.VERBOSE,
 )
 
 
-def parseTimeDeltaFromIsoFormat(duration_str):
-    """Parses an ISO 8601 duration string into a timedelta object.
+def parse_timedelta_from_iso_format(text: str) -> timedelta | None:
+    m = _ISO8601_DURATION_PATTERN.match(text)
+    if not m:
+        return None
 
-    https://en.wikipedia.org/wiki/ISO_8601#Durations
-    PnYnMnDTnHnMnS (where n is a number, supported)
-    PnW (weeks, supported)
-    P<date>T<time> (not implemented)
+    weeks = float(m.group("weeks").replace(",", ".").replace("W", "")) if m.group("weeks") else 0
+    years = float(m.group("years").replace(",", ".").replace("Y", "")) if m.group("years") else 0
+    months = float(m.group("months").replace(",", ".").replace("M", "")) if m.group("months") else 0
+    days = float(m.group("days").replace(",", ".").replace("D", "")) if m.group("days") else 0
+    hours = float(m.group("hours").replace(",", ".").replace("H", "")) if m.group("hours") else 0
+    minutes = float(m.group("minutes").replace(",", ".").replace("M", "")
+                    ) if m.group("minutes") else 0
+    seconds = float(m.group("seconds").replace(",", ".").replace("S", "")
+                    ) if m.group("seconds") else 0
 
-    Args:
-        duration_str (str): The ISO 8601 duration string.
-
-    Returns:
-        timedelta: The parsed timedelta object.
-    """
-    pattern = _ISO8601_DURATION_PATTERN
-    match = pattern.fullmatch(duration_str)
-    if not match:
-        raise ValueError(f"Invalid ISO 8601 duration string: {duration_str}")
+    if weeks and (years or months or days or hours or minutes or seconds):
+        raise ValueError("Invalid duration string")
 
-    years, months, weeks, days, hours, minutes, seconds = match.groups()
     return timedelta(
-        years=int(years or 0),
-        months=int(months or 0),
-        weeks=int(weeks or 0),
-        days=int(days or 0),
-        hours=int(hours or 0),
-        minutes=int(minutes or 0),
-        seconds=int(seconds or 0)
+        years=years,
+        months=months,
+        weeks=weeks,
+        days=days,
+        hours=hours,
+        minutes=minutes,
+        seconds=seconds
     )
diff --git a/packages/abstractions/tests/test_utils.py b/packages/abstractions/tests/test_utils.py
index 0b617ee..cf2e8a4 100644
--- a/packages/abstractions/tests/test_utils.py
+++ b/packages/abstractions/tests/test_utils.py
@@ -1,51 +1,56 @@
 import pytest
 
-from kiota_abstractions.utils import parseTimeDeltaFromIsoFormat
+from kiota_abstractions.utils import parse_timedelta_from_iso_format
 
 
-def test_parseTimeDeltaFromIsoFormat_weeks():
-    result = parseTimeDeltaFromIsoFormat("P3W")
+def test_parse_timedelta_from_iso_format_weeks():
+    result = parse_timedelta_from_iso_format("P3W")
     assert result.days == 21
 
 
-def test_parseTimeDeltaFromIsoFormat_days():
-    result = parseTimeDeltaFromIsoFormat("P3D")
+def test_parse_timedelta_from_iso_format_days():
+    result = parse_timedelta_from_iso_format("P3D")
     assert result.days == 3
 
 
-def test_parseTimeDeltaFromIsoFormat_hours():
-    result = parseTimeDeltaFromIsoFormat("PT3H")
+def test_parse_timedelta_from_iso_format_hours():
+    result = parse_timedelta_from_iso_format("PT3H")
     assert result.seconds == 10800
 
 
-def test_parseTimeDeltaFromIsoFormat_minutes():
-    result = parseTimeDeltaFromIsoFormat("PT3M")
+def test_parse_timedelta_from_iso_format_minutes():
+    result = parse_timedelta_from_iso_format("PT3M")
     assert result.seconds == 180
 
 
-def test_parseTimeDeltaFromIsoFormat_seconds():
-    result = parseTimeDeltaFromIsoFormat("PT3S")
+def test_parse_timedelta_from_iso_format_seconds():
+    result = parse_timedelta_from_iso_format("PT3S")
     assert result.seconds == 3
 
 
-def test_parseTimeDeltaFromIsoFormat_years():
-    result = parseTimeDeltaFromIsoFormat("P3Y")
+def test_parse_timedelta_from_iso_format_years():
+    result = parse_timedelta_from_iso_format("P3Y")
     assert result.days == 1095
 
 
-def test_parseTimeDeltaFromIsoFormat_months():
-    result = parseTimeDeltaFromIsoFormat("P3M")
+def test_parse_timedelta_from_iso_format_months():
+    result = parse_timedelta_from_iso_format("P3M")
     assert result.days == 90
 
-# This is "invalid" according to the ISO 8601 standard, but python also supports it
 
+def test_parse_timedelta_from_iso_format_days_and_time():
+    result = parse_timedelta_from_iso_format("P3DT3H3M3S")
+    assert result.days == 3
+    assert result.seconds == 10983
 
-def test_parseTimeDeltaFromIsoFormat_weeks_and_years():
-    result = parseTimeDeltaFromIsoFormat("P3Y3W")
-    assert result.days == 1122
 
+def test_parse_timedelta_from_iso_format_weeks_and_years():
+    # assert this raises a ValueError
+    with pytest.raises(ValueError):
+        parse_timedelta_from_iso_format("P3W3Y")
 
-def test_parseTimeDeltaFromIsoFormat_days_and_time():
-    result = parseTimeDeltaFromIsoFormat("P3DT3H3M3S")
-    assert result.days == 3
-    assert result.seconds == 10983
+
+def test_parse_timedelta_from_iso_format_years_and_weeks():
+    # assert this raises a ValueError
+    with pytest.raises(ValueError):
+        parse_timedelta_from_iso_format("P3Y3W")
diff --git a/packages/serialization/form/kiota_serialization_form/form_parse_node.py b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
index 0e855f0..ee0cf2f 100644
--- a/packages/serialization/form/kiota_serialization_form/form_parse_node.py
+++ b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
@@ -9,7 +9,7 @@
 from urllib.parse import unquote_plus
 from uuid import UUID
 
-from kiota_abstractions.utils import parseTimeDeltaFromIsoFormat
+from kiota_abstractions.utils import parse_timedelta_from_iso_format
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID,
@@ -108,7 +108,7 @@ def get_timedelta_value(self) -> Optional[timedelta]:
         """
         if self._node and self._node != "null":
             try:
-                return parseTimeDeltaFromIsoFormat(self._node)
+                return parse_timedelta_from_iso_format(self._node)
             except:
                 return None
         return None
@@ -323,7 +323,7 @@ def try_get_anything(self, value: Any) -> Any:
             except ValueError:
                 pass
             try:
-                return parseTimeDeltaFromIsoFormat(value)
+                return parse_timedelta_from_iso_format(value)
             except ValueError:
                 pass
             try:
diff --git a/packages/serialization/json/kiota_serialization_json/json_parse_node.py b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
index 35fa557..c2c1c78 100644
--- a/packages/serialization/json/kiota_serialization_json/json_parse_node.py
+++ b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
@@ -9,7 +9,7 @@
 from typing import Any, Optional, TypeVar
 from uuid import UUID
 
-from kiota_abstractions.utils import parseTimeDeltaFromIsoFormat
+from kiota_abstractions.utils import parse_timedelta_from_iso_format
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID,
@@ -113,7 +113,7 @@ def get_timedelta_value(self) -> Optional[timedelta]:
             return self._json_node
         if isinstance(self._json_node, str):
             try:
-                return parseTimeDeltaFromIsoFormat(self._json_node)
+                return parse_timedelta_from_iso_format(self._json_node)
             except ValueError:
                 return None
         return None
@@ -334,7 +334,7 @@ def try_get_anything(self, value: Any) -> Any:
             except:
                 pass
             try:
-                return parseTimeDeltaFromIsoFormat(value)
+                return parse_timedelta_from_iso_format(value)
             except ValueError:
                 pass
             try:
diff --git a/packages/serialization/text/kiota_serialization_text/text_parse_node.py b/packages/serialization/text/kiota_serialization_text/text_parse_node.py
index 5c76c95..302b3e9 100644
--- a/packages/serialization/text/kiota_serialization_text/text_parse_node.py
+++ b/packages/serialization/text/kiota_serialization_text/text_parse_node.py
@@ -7,7 +7,7 @@
 from typing import Optional, TypeVar
 from uuid import UUID
 
-from kiota_abstractions.utils import parseTimeDeltaFromIsoFormat
+from kiota_abstractions.utils import parse_timedelta_from_iso_format
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
@@ -105,7 +105,7 @@ def get_timedelta_value(self) -> Optional[timedelta]:
         """
         datetime_str = self.get_str_value()
         if datetime_str:
-            return parseTimeDeltaFromIsoFormat(datetime_str)
+            return parse_timedelta_from_iso_format(datetime_str)
         return None
 
     def get_date_value(self) -> Optional[date]:

From 74fbeeb62f99df448d8f91f2429f167c49233199 Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Wed, 15 Jan 2025 14:39:54 +0000
Subject: [PATCH 05/24] Fix issues caused by auto format

---
 .../form/kiota_serialization_form/form_parse_node.py           | 3 +--
 .../json/kiota_serialization_json/json_parse_node.py           | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/packages/serialization/form/kiota_serialization_form/form_parse_node.py b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
index ee0cf2f..45b71d6 100644
--- a/packages/serialization/form/kiota_serialization_form/form_parse_node.py
+++ b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
@@ -181,8 +181,7 @@ def get_collection_of_primitive_values(self, primitive_type: type[T]) -> Optiona
                 method = getattr(current_parse_node, method_name)
                 result.append(method())
             return result
-        raise Exception(f"Encountered an unknown type during deserialization {
-                        primitive_type}")
+        raise Exception(f"Encountered an unknown type during deserialization {primitive_type}")
 
     def get_collection_of_object_values(self, factory: ParsableFactory[U]) -> Optional[list[U]]:
         raise Exception(
diff --git a/packages/serialization/json/kiota_serialization_json/json_parse_node.py b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
index c2c1c78..ec96ac8 100644
--- a/packages/serialization/json/kiota_serialization_json/json_parse_node.py
+++ b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
@@ -159,8 +159,7 @@ def func(item):
             generic_type = primitive_type if primitive_type else type(item)
             current_parse_node = self._create_new_node(item)
             if generic_type in primitive_types:
-                method = getattr(current_parse_node, f'get_{
-                                 generic_type.__name__.lower()}_value')
+                method = getattr(current_parse_node, f'get_{generic_type.__name__.lower()}_value')
                 return method()
             raise Exception(
                 f"Encountered an unknown type during deserialization {generic_type}")

From e6eb346c55ee6a4c1d9dddd44cf3c11eceb9b633 Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Wed, 15 Jan 2025 14:59:59 +0000
Subject: [PATCH 06/24] More pendulem removed

---
 .../tests/unit/test_form_serialization_writer.py  |  5 ++---
 .../json_serialization_writer.py                  | 10 +++++-----
 .../json/tests/unit/test_json_parse_node.py       |  8 ++------
 .../tests/unit/test_json_serialization_writer.py  | 15 +++++++--------
 packages/serialization/multipart/pyproject.toml   |  1 -
 5 files changed, 16 insertions(+), 23 deletions(-)

diff --git a/packages/serialization/form/tests/unit/test_form_serialization_writer.py b/packages/serialization/form/tests/unit/test_form_serialization_writer.py
index e1dd250..f2e6fec 100644
--- a/packages/serialization/form/tests/unit/test_form_serialization_writer.py
+++ b/packages/serialization/form/tests/unit/test_form_serialization_writer.py
@@ -2,7 +2,6 @@
 from urllib.parse import unquote_plus
 import pytest
 
-import pendulum
 from datetime import datetime, timedelta, date, time
 from kiota_serialization_form.form_serialization_writer import FormSerializationWriter
 from ..helpers import TestEntity, TestEnum
@@ -11,7 +10,7 @@
 @pytest.fixture
 def user_1():
     user = TestEntity()
-    user.created_date_time = pendulum.parse("2022-01-27T12:59:45.596117")
+    user.created_date_time = datetime.fromisoformat("2022-01-27T12:59:45.596117")
     user.work_duration  = timedelta(seconds=7200)
     user.birthday = date(year=2000,month=9,day=4)
     user.start_work_time = time(hour=8, minute=0, second=0)
@@ -112,7 +111,7 @@ def test_write_time_value():
     form_serialization_writer = FormSerializationWriter()
     form_serialization_writer.write_time_value(
         "time",
-        pendulum.parse('2022-01-27T12:59:45.596117').time()
+        datetime.fromisoformat('2022-01-27T12:59:45.596117').time()
     )
     content = form_serialization_writer.get_serialized_content()
     content_string = content.decode('utf-8')
diff --git a/packages/serialization/json/kiota_serialization_json/json_serialization_writer.py b/packages/serialization/json/kiota_serialization_json/json_serialization_writer.py
index e076cef..e81644b 100644
--- a/packages/serialization/json/kiota_serialization_json/json_serialization_writer.py
+++ b/packages/serialization/json/kiota_serialization_json/json_serialization_writer.py
@@ -8,7 +8,7 @@
 from typing import Any, Optional, TypeVar
 from uuid import UUID
 
-import pendulum
+from kiota_abstractions.utils import parse_timedelta_from_iso_format
 from kiota_abstractions.serialization import Parsable, SerializationWriter
 
 T = TypeVar("T")
@@ -115,7 +115,7 @@ def write_datetime_value(self, key: Optional[str], value: Optional[datetime]) ->
                 self.value = value.isoformat()
         elif isinstance(value, str):
             try:
-                pendulum.parse(value)
+                datetime.fromisoformat(value)
                 if key:
                     self.writer[key] = value
                 else:
@@ -138,7 +138,7 @@ def write_timedelta_value(self, key: Optional[str], value: Optional[timedelta])
                 self.value = str(value)
         elif isinstance(value, str):
             try:
-                pendulum.parse(value)
+                parse_timedelta_from_iso_format(value)
                 if key:
                     self.writer[key] = value
                 else:
@@ -161,7 +161,7 @@ def write_date_value(self, key: Optional[str], value: Optional[date]) -> None:
                 self.value = str(value)
         elif isinstance(value, str):
             try:
-                pendulum.parse(value)
+                date.fromisoformat(value)
                 if key:
                     self.writer[key] = value
                 else:
@@ -184,7 +184,7 @@ def write_time_value(self, key: Optional[str], value: Optional[time]) -> None:
                 self.value = str(value)
         elif isinstance(value, str):
             try:
-                pendulum.parse(value)
+                time.fromisoformat(value)
                 if key:
                     self.writer[key] = value
                 else:
diff --git a/packages/serialization/json/tests/unit/test_json_parse_node.py b/packages/serialization/json/tests/unit/test_json_parse_node.py
index 8e0ce45..04e1f9e 100644
--- a/packages/serialization/json/tests/unit/test_json_parse_node.py
+++ b/packages/serialization/json/tests/unit/test_json_parse_node.py
@@ -1,10 +1,8 @@
 import json
 from datetime import date, datetime, time, timedelta
 from uuid import UUID
-import pendulum
 
 import pytest
-from pendulum import DateTime, FixedTimezone
 from kiota_serialization_json.json_parse_node import JsonParseNode
 from ..helpers import OfficeLocation, User
 
@@ -182,16 +180,14 @@ def test_get_object_value(user1_json):
     )
     assert result.additional_data["additional_data"]["manager"] == {
         "id": UUID("8f841f30-e6e3-439a-a812-ebd369559c36"),
-        "updated_at":
-        DateTime(2022, 1, 27, 12, 59, 45, 596117, tzinfo=FixedTimezone(0, name="+00:00")),
+        "updated_at": datetime(2022, 1, 27, 12, 59, 45, 596117),
         "is_active": True,
     }
     assert result.additional_data["additional_data"]["approvers"] == [
         {
             "id":
             UUID("8f841f30-e6e3-439a-a812-ebd369559c36"),
-            "updated_at":
-            DateTime(2022, 1, 27, 12, 59, 45, 596117, tzinfo=FixedTimezone(0, name="+00:00")),
+            "updated_at": datetime(2022, 1, 27, 12, 59, 45, 596117),
             "is_active":
             True,
         },
diff --git a/packages/serialization/json/tests/unit/test_json_serialization_writer.py b/packages/serialization/json/tests/unit/test_json_serialization_writer.py
index 48ee7f8..15e9263 100644
--- a/packages/serialization/json/tests/unit/test_json_serialization_writer.py
+++ b/packages/serialization/json/tests/unit/test_json_serialization_writer.py
@@ -1,9 +1,8 @@
-from datetime import date
+from datetime import date, datetime
 from uuid import UUID
 
 import pytest
 
-import pendulum
 from kiota_serialization_json.json_serialization_writer import JsonSerializationWriter
 
 from ..helpers import OfficeLocation, User, User2
@@ -12,7 +11,7 @@
 @pytest.fixture
 def user_1():
     user = User()
-    user.updated_at = pendulum.parse("2022-01-27T12:59:45.596117")
+    user.updated_at = datetime(2022,1,27,12,59,45,596117).fromisoformat("2022-01-27T12:59:45.596117")
     user.is_active = True
     user.id = UUID("8f841f30-e6e3-439a-a812-ebd369559c36")
     return user
@@ -92,7 +91,7 @@ def test_write_uuid_value_with_invalid_string():
 def test_write_datetime_value():
     json_serialization_writer = JsonSerializationWriter()
     json_serialization_writer.write_datetime_value(
-        "updatedAt", pendulum.parse('2022-01-27T12:59:45.596117')
+        "updatedAt", datetime.fromisoformat('2022-01-27T12:59:45.596117')
     )
     content = json_serialization_writer.get_serialized_content()
     content_string = content.decode('utf-8')
@@ -118,8 +117,8 @@ def test_write_timedelta_value():
     json_serialization_writer = JsonSerializationWriter()
     json_serialization_writer.write_timedelta_value(
         "diff", (
-            pendulum.parse('2022-01-27T12:59:45.596117') -
-            pendulum.parse('2022-01-27T10:59:45.596117')
+            datetime.fromisoformat('2022-01-27T12:59:45.596117') -
+            datetime.fromisoformat('2022-01-27T10:59:45.596117')
         ).as_timedelta()
     )
     content = json_serialization_writer.get_serialized_content()
@@ -144,7 +143,7 @@ def test_write_timedelta_value_invalid_string():
 
 def test_write_date_value():
     json_serialization_writer = JsonSerializationWriter()
-    json_serialization_writer.write_date_value("birthday", pendulum.parse("2000-09-04").date())
+    json_serialization_writer.write_date_value("birthday", date(2000,9,4))
     content = json_serialization_writer.get_serialized_content()
     content_string = content.decode('utf-8')
     assert content_string == '{"birthday": "2000-09-04"}'
@@ -169,7 +168,7 @@ def test_write_time_value():
     json_serialization_writer = JsonSerializationWriter()
     json_serialization_writer.write_time_value(
         "time",
-        pendulum.parse('2022-01-27T12:59:45.596117').time()
+        datetime.fromisoformat('2022-01-27T12:59:45.596117').time()
     )
     content = json_serialization_writer.get_serialized_content()
     content_string = content.decode('utf-8')
diff --git a/packages/serialization/multipart/pyproject.toml b/packages/serialization/multipart/pyproject.toml
index 0ef831c..2e4d1f9 100644
--- a/packages/serialization/multipart/pyproject.toml
+++ b/packages/serialization/multipart/pyproject.toml
@@ -25,7 +25,6 @@ packages = [{include = "kiota_serialization_multipart"}]
 [tool.poetry.dependencies]
 python = ">=3.9,<4.0"
 microsoft-kiota-abstractions = {path="../../abstractions/", develop=true}
-pendulum = ">=3.0.0"
 
 [tool.poetry.group.dev.dependencies]
 yapf = "^0.40.2"

From e61eabb2c9adb968ff76bdb34b0222f818ca5a41 Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Wed, 15 Jan 2025 15:50:48 +0000
Subject: [PATCH 07/24] Reduce complexity and raise error instead of return
 none

---
 .../abstractions/kiota_abstractions/utils.py  | 22 ++++++++++---------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/packages/abstractions/kiota_abstractions/utils.py b/packages/abstractions/kiota_abstractions/utils.py
index 128a9b0..4ca2150 100644
--- a/packages/abstractions/kiota_abstractions/utils.py
+++ b/packages/abstractions/kiota_abstractions/utils.py
@@ -65,10 +65,12 @@ def lazy_import(name):
 )
 
 
-def parse_timedelta_from_iso_format(text: str) -> timedelta | None:
+def parse_timedelta_from_iso_format(text: str) -> timedelta:
+    """Parses a ISO8601 duration string into a timedelta object."""
+
     m = _ISO8601_DURATION_PATTERN.match(text)
     if not m:
-        return None
+        raise ValueError(f"Invalid ISO8601 duration string: {text}")
 
     weeks = float(m.group("weeks").replace(",", ".").replace("W", "")) if m.group("weeks") else 0
     years = float(m.group("years").replace(",", ".").replace("Y", "")) if m.group("years") else 0
@@ -79,16 +81,16 @@ def parse_timedelta_from_iso_format(text: str) -> timedelta | None:
                     ) if m.group("minutes") else 0
     seconds = float(m.group("seconds").replace(",", ".").replace("S", "")
                     ) if m.group("seconds") else 0
+    _have_date = years or months or days
+    _have_time = hours or minutes or seconds
+    if weeks and (_have_date or _have_time):
+        raise ValueError("Combining weeks with other date/time parts is not supported")
 
-    if weeks and (years or months or days or hours or minutes or seconds):
-        raise ValueError("Invalid duration string")
-
+    _total_days = (years * 365) + (months * 30) + days
     return timedelta(
-        years=years,
-        months=months,
-        weeks=weeks,
-        days=days,
+        days=_total_days,
         hours=hours,
         minutes=minutes,
-        seconds=seconds
+        seconds=seconds,
+        weeks=weeks,
     )

From 5a2205a1ca14b88020a13b834ef0111b72b4dc77 Mon Sep 17 00:00:00 2001
From: Vincent Biret <vibiret@microsoft.com>
Date: Wed, 15 Jan 2025 12:28:19 -0500
Subject: [PATCH 08/24] ci: disables fail fast to get all feedback at once

Signed-off-by: Vincent Biret <vibiret@microsoft.com>
---
 .github/workflows/build.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 954dfb1..2363ed8 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -17,6 +17,7 @@ jobs:
     timeout-minutes: 40
     strategy:
       max-parallel: 10
+      fail-fast: false
       matrix:
         python-version: ["3.9", "3.10", "3.11", "3.12"]
         library : 

From d7af3e3850211a98d27bbf34c1ba8ac01b08d446 Mon Sep 17 00:00:00 2001
From: Vincent Biret <vibiret@microsoft.com>
Date: Wed, 15 Jan 2025 12:46:31 -0500
Subject: [PATCH 09/24] chore: minor formatting fixes

Signed-off-by: Vincent Biret <vibiret@microsoft.com>
---
 .../form/kiota_serialization_form/form_parse_node.py        | 6 ++----
 .../json/kiota_serialization_json/json_parse_node.py        | 3 +--
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/packages/serialization/form/kiota_serialization_form/form_parse_node.py b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
index 45b71d6..d17343e 100644
--- a/packages/serialization/form/kiota_serialization_form/form_parse_node.py
+++ b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
@@ -216,13 +216,11 @@ def get_enum_value(self, enum_class: K) -> Optional[K]:
             return enum_class(self._node)  # type: ignore
         values = self._node.split(',')
         if not len(values) > 1:
-            raise Exception(f'Invalid value: {
-                            self._node} for enum {enum_class}.')
+            raise Exception(f'Invalid value: {self._node} for enum {enum_class}.')
         result = []
         for value in values:
             if value not in enum_values:
-                raise Exception(f'Invalid value: {
-                                value} for enum {enum_class}.')
+                raise Exception(f'Invalid value: {value} for enum {enum_class}.')
             result.append(enum_class(value))  # type: ignore
         return result  # type: ignore
 
diff --git a/packages/serialization/json/kiota_serialization_json/json_parse_node.py b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
index ec96ac8..a67acda 100644
--- a/packages/serialization/json/kiota_serialization_json/json_parse_node.py
+++ b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
@@ -345,8 +345,7 @@ def try_get_anything(self, value: Any) -> Any:
             except ValueError:
                 pass
             return value
-        raise ValueError(f"Unexpected additional value type {
-                         type(value)} during deserialization.")
+        raise ValueError(f"Unexpected additional value type {type(value)} during deserialization.")
 
     def _create_new_node(self, node: Any) -> JsonParseNode:
         new_node: JsonParseNode = JsonParseNode(node)

From 4540b25c720faee86114ff0893ee30f9c1074097 Mon Sep 17 00:00:00 2001
From: Vincent Biret <vibiret@microsoft.com>
Date: Wed, 15 Jan 2025 12:51:02 -0500
Subject: [PATCH 10/24] chore: additional formatting issue

Signed-off-by: Vincent Biret <vibiret@microsoft.com>
---
 .../form/kiota_serialization_form/form_parse_node.py           | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/packages/serialization/form/kiota_serialization_form/form_parse_node.py b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
index d17343e..2375a2a 100644
--- a/packages/serialization/form/kiota_serialization_form/form_parse_node.py
+++ b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
@@ -332,8 +332,7 @@ def try_get_anything(self, value: Any) -> Any:
             except ValueError:
                 pass
             return value
-        raise ValueError(f"Unexpected additional value type {
-                         type(value)} during deserialization.")
+        raise ValueError(f"Unexpected additional value type {type(value)} during deserialization.")
 
     def _create_new_node(self, node: Any) -> FormParseNode:
         new_node: FormParseNode = FormParseNode(node)

From 58a81219d762dcaa0a69c4f0d3b4db0fd45889be Mon Sep 17 00:00:00 2001
From: Vincent Biret <vibiret@microsoft.com>
Date: Wed, 15 Jan 2025 12:53:03 -0500
Subject: [PATCH 11/24] chore: additional formatting issues

Signed-off-by: Vincent Biret <vibiret@microsoft.com>
---
 .../json_parse_node.py                        | 24 +++++++------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/packages/serialization/json/kiota_serialization_json/json_parse_node.py b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
index a67acda..a2b2d79 100644
--- a/packages/serialization/json/kiota_serialization_json/json_parse_node.py
+++ b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
@@ -12,8 +12,7 @@
 from kiota_abstractions.utils import parse_timedelta_from_iso_format
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
-T = TypeVar("T", bool, str, int, float, UUID,
-            datetime, timedelta, date, time, bytes)
+T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
 
 U = TypeVar("U", bound=Parsable)
 
@@ -29,10 +28,8 @@ def __init__(self, node: Any) -> None:
                 to initialize the node with
         """
         self._json_node = node
-        self._on_before_assign_field_values: Optional[Callable[[
-            Parsable], None]] = None
-        self._on_after_assign_field_values: Optional[Callable[[
-            Parsable], None]] = None
+        self._on_before_assign_field_values: Optional[Callable[[Parsable], None]] = None
+        self._on_after_assign_field_values: Optional[Callable[[Parsable], None]] = None
 
     def get_child_node(self, identifier: str) -> Optional[ParseNode]:
         """Gets a new parse node for the given identifier
@@ -152,8 +149,7 @@ def get_collection_of_primitive_values(self, primitive_type: type[T]) -> Optiona
             list[T]: The collection of primitive values
         """
 
-        primitive_types = {bool, str, int, float, UUID,
-                           datetime, timedelta, date, time, bytes}
+        primitive_types = {bool, str, int, float, UUID, datetime, timedelta, date, time, bytes}
 
         def func(item):
             generic_type = primitive_type if primitive_type else type(item)
@@ -161,8 +157,7 @@ def func(item):
             if generic_type in primitive_types:
                 method = getattr(current_parse_node, f'get_{generic_type.__name__.lower()}_value')
                 return method()
-            raise Exception(
-                f"Encountered an unknown type during deserialization {generic_type}")
+            raise Exception(f"Encountered an unknown type during deserialization {generic_type}")
 
         if isinstance(self._json_node, str):
             return list(map(func, json.loads(self._json_node)))
@@ -176,8 +171,7 @@ def get_collection_of_object_values(self, factory: ParsableFactory[U]) -> Option
         if isinstance(self._json_node, list):
             return list(
                 map(
-                    lambda x: self._create_new_node(
-                        x).get_object_value(factory),  # type: ignore
+                    lambda x: self._create_new_node(x).get_object_value(factory),  # type: ignore
                     self._json_node,
                 )
             )
@@ -191,8 +185,7 @@ def get_collection_of_enum_values(self, enum_class: K) -> Optional[list[K]]:
         if isinstance(self._json_node, list):
             return list(
                 map(
-                    lambda x: self._create_new_node(
-                        x).get_enum_value(enum_class),  # type: ignore
+                    lambda x: self._create_new_node(x).get_enum_value(enum_class),  # type: ignore
                     self._json_node
                 )
             )
@@ -299,8 +292,7 @@ def _assign_field_values(self, item: Parsable) -> None:
                 field_deserializer = field_deserializers[field_name]
                 field_deserializer(JsonParseNode(field_value))
             elif item_additional_data is not None:
-                item_additional_data[field_name] = self.try_get_anything(
-                    field_value)
+                item_additional_data[field_name] = self.try_get_anything(field_value)
             else:
                 warnings.warn(
                     f"Found additional property {field_name} to \

From f9d9e84fbbd6c18ebb93203f1f0271f395981784 Mon Sep 17 00:00:00 2001
From: Vincent Biret <vibiret@microsoft.com>
Date: Wed, 15 Jan 2025 12:55:52 -0500
Subject: [PATCH 12/24] fix: replace calls to parser by iso format

Signed-off-by: Vincent Biret <vibiret@microsoft.com>
---
 .../unit/test_text_serialization_writer.py     | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/packages/serialization/text/tests/unit/test_text_serialization_writer.py b/packages/serialization/text/tests/unit/test_text_serialization_writer.py
index 0911e15..cc02f6c 100644
--- a/packages/serialization/text/tests/unit/test_text_serialization_writer.py
+++ b/packages/serialization/text/tests/unit/test_text_serialization_writer.py
@@ -1,7 +1,7 @@
 from uuid import UUID
 
 import pytest
-from dateutil import parser
+from datetime import date, datetime
 from kiota_abstractions.serialization import Parsable, SerializationWriter
 
 from kiota_serialization_text.text_serialization_writer import TextSerializationWriter
@@ -101,7 +101,7 @@ def test_write_uuid_value_with_key():
 
 def test_write_datetime_value():
     text_serialization_writer = TextSerializationWriter()
-    text_serialization_writer.write_datetime_value("", parser.parse('2022-01-27T12:59:45.596117'))
+    text_serialization_writer.write_datetime_value("", datetime.fromisoformat('2022-01-27T12:59:45.596117'))
     content = text_serialization_writer.get_serialized_content()
     content_string = content.decode('utf-8')
     assert content_string == "2022-01-27T12:59:45.596117"
@@ -111,7 +111,7 @@ def test_write_datetime_value_with_key():
     with pytest.raises(Exception) as e_info:
         text_serialization_writer = TextSerializationWriter()
         text_serialization_writer.write_datetime_value(
-            "updatedAt", parser.parse('2022-01-27T12:59:45.596117')
+            "updatedAt", datetime.fromisoformat('2022-01-27T12:59:45.596117')
         )
 
 
@@ -119,7 +119,7 @@ def test_write_timedelta_value():
     text_serialization_writer = TextSerializationWriter()
     text_serialization_writer.write_timedelta_value(
         "",
-        parser.parse('2022-01-27T12:59:45.596117') - parser.parse('2022-01-27T10:59:45.596117')
+        datetime.fromisoformat('2022-01-27T12:59:45.596117') - datetime.fromisoformat('2022-01-27T10:59:45.596117')
     )
     content = text_serialization_writer.get_serialized_content()
     content_string = content.decode('utf-8')
@@ -131,13 +131,13 @@ def test_write_timedelta_value_with_key():
         text_serialization_writer = TextSerializationWriter()
         text_serialization_writer.write_timedelta_value(
             "diff",
-            parser.parse('2022-01-27T12:59:45.596117') - parser.parse('2022-01-27T10:59:45.596117')
+            datetime.fromisoformat('2022-01-27T12:59:45.596117') - datetime.fromisoformat('2022-01-27T10:59:45.596117')
         )
 
 
 def test_write_date_value():
     text_serialization_writer = TextSerializationWriter()
-    text_serialization_writer.write_date_value("", parser.parse("2000-09-04").date())
+    text_serialization_writer.write_date_value("", date.fromisoformat("2000-09-04").date())
     content = text_serialization_writer.get_serialized_content()
     content_string = content.decode('utf-8')
     assert content_string == "2000-09-04"
@@ -146,14 +146,14 @@ def test_write_date_value():
 def test_write_date_value_with_key():
     with pytest.raises(Exception) as e_info:
         text_serialization_writer = TextSerializationWriter()
-        text_serialization_writer.write_date_value("birthday", parser.parse("2000-09-04").date())
+        text_serialization_writer.write_date_value("birthday", date.fromisoformat("2000-09-04").date())
 
 
 def test_write_time_value():
     text_serialization_writer = TextSerializationWriter()
     text_serialization_writer.write_time_value(
         "",
-        parser.parse('2022-01-27T12:59:45.596117').time()
+        datetime.fromisoformat('2022-01-27T12:59:45.596117').time()
     )
     content = text_serialization_writer.get_serialized_content()
     content_string = content.decode('utf-8')
@@ -165,7 +165,7 @@ def test_write_time_value_with_key():
         text_serialization_writer = TextSerializationWriter()
         text_serialization_writer.write_time_value(
             "time",
-            parser.parse('2022-01-27T12:59:45.596117').time()
+            datetime.fromisoformat('2022-01-27T12:59:45.596117').time()
         )
 
 

From f4a5692965cfcf28549d66d6b94303ee55f9c3db Mon Sep 17 00:00:00 2001
From: Vincent Biret <vibiret@microsoft.com>
Date: Wed, 15 Jan 2025 12:56:45 -0500
Subject: [PATCH 13/24] chore: additional formatting

Signed-off-by: Vincent Biret <vibiret@microsoft.com>
---
 .../form_parse_node.py                        | 24 +++++++------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/packages/serialization/form/kiota_serialization_form/form_parse_node.py b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
index 2375a2a..7984b7b 100644
--- a/packages/serialization/form/kiota_serialization_form/form_parse_node.py
+++ b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
@@ -12,8 +12,7 @@
 from kiota_abstractions.utils import parse_timedelta_from_iso_format
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
-T = TypeVar("T", bool, str, int, float, UUID,
-            datetime, timedelta, date, time, bytes)
+T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
 
 U = TypeVar("U", bound=Parsable)
 
@@ -27,10 +26,8 @@ def __init__(self, raw_value: str) -> None:
         self._raw_value = raw_value
         self._node = unquote_plus(raw_value)
         self._fields = self._get_fields(raw_value)
-        self._on_before_assign_field_values: Optional[Callable[[
-            Parsable], None]] = None
-        self._on_after_assign_field_values: Optional[Callable[[
-            Parsable], None]] = None
+        self._on_before_assign_field_values: Optional[Callable[[Parsable], None]] = None
+        self._on_after_assign_field_values: Optional[Callable[[Parsable], None]] = None
 
     def get_str_value(self) -> Optional[str]:
         """Gets the string value from the node
@@ -167,11 +164,9 @@ def get_collection_of_primitive_values(self, primitive_type: type[T]) -> Optiona
             list[T]: The collection of primitive values
         """
         if not primitive_type:
-            raise Exception(
-                "Primitive type for deserialization cannot be null")
+            raise Exception("Primitive type for deserialization cannot be null")
 
-        primitive_types = {bool, str, int, float, UUID,
-                           datetime, timedelta, date, time, bytes}
+        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] = []
@@ -184,8 +179,7 @@ def get_collection_of_primitive_values(self, primitive_type: type[T]) -> Optiona
         raise Exception(f"Encountered an unknown type during deserialization {primitive_type}")
 
     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.")
+        raise Exception("Collection of object values is not supported with uri form encoding.")
 
     def get_collection_of_enum_values(self, enum_class: K) -> Optional[list[K]]:
         """Gets the collection of enum values of the node
@@ -196,8 +190,7 @@ def get_collection_of_enum_values(self, enum_class: K) -> Optional[list[K]]:
         if values:
             return list(
                 map(
-                    lambda x: self._create_new_node(
-                        x).get_enum_value(enum_class),  # type: ignore
+                    lambda x: self._create_new_node(x).get_enum_value(enum_class),  # type: ignore
                     values
                 )
             )
@@ -294,8 +287,7 @@ def _assign_field_values(self, item: Parsable) -> None:
                 field_deserializer = field_deserializers[field_name]
                 field_deserializer(FormParseNode(field_value))
             elif item_additional_data is not None:
-                item_additional_data[field_name] = self.try_get_anything(
-                    field_value)
+                item_additional_data[field_name] = self.try_get_anything(field_value)
             else:
                 warnings.warn(
                     f"Found additional property {field_name} to \

From fedf34c03a7a8a97d8d735782aa2d55c7f3f5739 Mon Sep 17 00:00:00 2001
From: Vincent Biret <vibiret@microsoft.com>
Date: Wed, 15 Jan 2025 13:11:51 -0500
Subject: [PATCH 14/24] fix: multiple text failing tests

Signed-off-by: Vincent Biret <vibiret@microsoft.com>
---
 .../serialization/text/tests/unit/test_text_parse_node.py   | 6 +++---
 .../text/tests/unit/test_text_serialization_writer.py       | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/packages/serialization/text/tests/unit/test_text_parse_node.py b/packages/serialization/text/tests/unit/test_text_parse_node.py
index 9a35930..d1a93d1 100644
--- a/packages/serialization/text/tests/unit/test_text_parse_node.py
+++ b/packages/serialization/text/tests/unit/test_text_parse_node.py
@@ -66,21 +66,21 @@ def test_get_datetime_value():
 
 
 def test_get_date_value():
-    parse_node = TextParseNode('2015-04-20T11:50:51Z')
+    parse_node = TextParseNode('2015-04-20')
     result = parse_node.get_date_value()
     assert isinstance(result, date)
     assert str(result) == '2015-04-20'
 
 
 def test_get_time_value():
-    parse_node = TextParseNode('2022-01-27T12:59:45.596117')
+    parse_node = TextParseNode('12:59:45.596117')
     result = parse_node.get_time_value()
     assert isinstance(result, time)
     assert str(result) == '12:59:45.596117'
 
 
 def test_get_timedelta_value():
-    parse_node = TextParseNode('2022-01-27T12:59:45.596117')
+    parse_node = TextParseNode('T12H59M45S')
     result = parse_node.get_timedelta_value()
     assert isinstance(result, timedelta)
     assert str(result) == '12:59:45'
diff --git a/packages/serialization/text/tests/unit/test_text_serialization_writer.py b/packages/serialization/text/tests/unit/test_text_serialization_writer.py
index cc02f6c..63907ab 100644
--- a/packages/serialization/text/tests/unit/test_text_serialization_writer.py
+++ b/packages/serialization/text/tests/unit/test_text_serialization_writer.py
@@ -137,7 +137,7 @@ def test_write_timedelta_value_with_key():
 
 def test_write_date_value():
     text_serialization_writer = TextSerializationWriter()
-    text_serialization_writer.write_date_value("", date.fromisoformat("2000-09-04").date())
+    text_serialization_writer.write_date_value("", date.fromisoformat("2000-09-04"))
     content = text_serialization_writer.get_serialized_content()
     content_string = content.decode('utf-8')
     assert content_string == "2000-09-04"
@@ -146,7 +146,7 @@ def test_write_date_value():
 def test_write_date_value_with_key():
     with pytest.raises(Exception) as e_info:
         text_serialization_writer = TextSerializationWriter()
-        text_serialization_writer.write_date_value("birthday", date.fromisoformat("2000-09-04").date())
+        text_serialization_writer.write_date_value("birthday", date.fromisoformat("2000-09-04"))
 
 
 def test_write_time_value():

From 42f1b5bcc263620dbe08fb8abc18a0452bc9a66d Mon Sep 17 00:00:00 2001
From: Vincent Biret <vibiret@microsoft.com>
Date: Wed, 15 Jan 2025 13:26:31 -0500
Subject: [PATCH 15/24] chore: additional fixture data corrections

Signed-off-by: Vincent Biret <vibiret@microsoft.com>
---
 .../form/tests/unit/test_form_serialization_writer.py           | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/serialization/form/tests/unit/test_form_serialization_writer.py b/packages/serialization/form/tests/unit/test_form_serialization_writer.py
index f2e6fec..951aa1e 100644
--- a/packages/serialization/form/tests/unit/test_form_serialization_writer.py
+++ b/packages/serialization/form/tests/unit/test_form_serialization_writer.py
@@ -10,7 +10,7 @@
 @pytest.fixture
 def user_1():
     user = TestEntity()
-    user.created_date_time = datetime.fromisoformat("2022-01-27T12:59:45.596117")
+    user.created_date_time = datetime.fromisoformat("2022-01-27T12:59:45.596117+00:00")
     user.work_duration  = timedelta(seconds=7200)
     user.birthday = date(year=2000,month=9,day=4)
     user.start_work_time = time(hour=8, minute=0, second=0)

From e9021c91ff14cdd829a5097b9774097d8054828c Mon Sep 17 00:00:00 2001
From: Vincent Biret <vibiret@microsoft.com>
Date: Wed, 15 Jan 2025 13:52:00 -0500
Subject: [PATCH 16/24] fix: additional fixes for unit test setup

Signed-off-by: Vincent Biret <vibiret@microsoft.com>
---
 .../serialization/json/tests/unit/test_json_parse_node.py   | 6 +++---
 .../json/tests/unit/test_json_serialization_writer.py       | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/packages/serialization/json/tests/unit/test_json_parse_node.py b/packages/serialization/json/tests/unit/test_json_parse_node.py
index 04e1f9e..3ca619d 100644
--- a/packages/serialization/json/tests/unit/test_json_parse_node.py
+++ b/packages/serialization/json/tests/unit/test_json_parse_node.py
@@ -1,5 +1,5 @@
 import json
-from datetime import date, datetime, time, timedelta
+from datetime import date, datetime, time, timedelta, timezone
 from uuid import UUID
 
 import pytest
@@ -180,14 +180,14 @@ def test_get_object_value(user1_json):
     )
     assert result.additional_data["additional_data"]["manager"] == {
         "id": UUID("8f841f30-e6e3-439a-a812-ebd369559c36"),
-        "updated_at": datetime(2022, 1, 27, 12, 59, 45, 596117),
+        "updated_at": datetime(2022, 1, 27, 12, 59, 45, 596117, timezone.utc),
         "is_active": True,
     }
     assert result.additional_data["additional_data"]["approvers"] == [
         {
             "id":
             UUID("8f841f30-e6e3-439a-a812-ebd369559c36"),
-            "updated_at": datetime(2022, 1, 27, 12, 59, 45, 596117),
+            "updated_at": datetime(2022, 1, 27, 12, 59, 45, 596117, timezone.utc),
             "is_active":
             True,
         },
diff --git a/packages/serialization/json/tests/unit/test_json_serialization_writer.py b/packages/serialization/json/tests/unit/test_json_serialization_writer.py
index 15e9263..ad0bd2a 100644
--- a/packages/serialization/json/tests/unit/test_json_serialization_writer.py
+++ b/packages/serialization/json/tests/unit/test_json_serialization_writer.py
@@ -11,7 +11,7 @@
 @pytest.fixture
 def user_1():
     user = User()
-    user.updated_at = datetime(2022,1,27,12,59,45,596117).fromisoformat("2022-01-27T12:59:45.596117")
+    user.updated_at = datetime(2022,1,27,12,59,45,596117).fromisoformat("2022-01-27T12:59:45.596117+00:00")
     user.is_active = True
     user.id = UUID("8f841f30-e6e3-439a-a812-ebd369559c36")
     return user
@@ -91,7 +91,7 @@ def test_write_uuid_value_with_invalid_string():
 def test_write_datetime_value():
     json_serialization_writer = JsonSerializationWriter()
     json_serialization_writer.write_datetime_value(
-        "updatedAt", datetime.fromisoformat('2022-01-27T12:59:45.596117')
+        "updatedAt", datetime.fromisoformat('2022-01-27T12:59:45.596117+00:00')
     )
     content = json_serialization_writer.get_serialized_content()
     content_string = content.decode('utf-8')
@@ -119,7 +119,7 @@ def test_write_timedelta_value():
         "diff", (
             datetime.fromisoformat('2022-01-27T12:59:45.596117') -
             datetime.fromisoformat('2022-01-27T10:59:45.596117')
-        ).as_timedelta()
+        )
     )
     content = json_serialization_writer.get_serialized_content()
     content_string = content.decode('utf-8')

From f0ed7800597ea6789e421efeafd627164e3fb899 Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Thu, 16 Jan 2025 11:59:49 +0000
Subject: [PATCH 17/24] Support additional timedeltas

---
 .../kiota_abstractions/date_utils.py          | 76 +++++++++++++++++++
 .../abstractions/kiota_abstractions/utils.py  | 57 --------------
 .../{test_utils.py => test_date_utils.py}     | 21 +++--
 .../form_parse_node.py                        |  6 +-
 .../json_parse_node.py                        |  6 +-
 .../json_serialization_writer.py              |  4 +-
 .../text_parse_node.py                        |  4 +-
 7 files changed, 100 insertions(+), 74 deletions(-)
 create mode 100644 packages/abstractions/kiota_abstractions/date_utils.py
 rename packages/abstractions/tests/{test_utils.py => test_date_utils.py} (62%)

diff --git a/packages/abstractions/kiota_abstractions/date_utils.py b/packages/abstractions/kiota_abstractions/date_utils.py
new file mode 100644
index 0000000..d14dca6
--- /dev/null
+++ b/packages/abstractions/kiota_abstractions/date_utils.py
@@ -0,0 +1,76 @@
+import re
+from datetime import timedelta
+
+
+_ISO8601_DURATION_PATTERN = re.compile(
+    "^P?"  # Duration P indicator (was optional in previous parsing library)
+    # Weeks
+    "(?P<w>"
+    r"    (?P<weeks>\d+(?:[.,]\d+)?W)"
+    ")?"
+    # Years, Months, Days
+    "(?P<ymd>"
+    r"    (?P<years>\d+(?:[.,]\d+)?Y)?"
+    r"    (?P<months>\d+(?:[.,]\d+)?M)?"
+    r"    (?P<days>\d+(?:[.,]\d+)?D)?"
+    ")?"
+    # Time
+    "(?P<hms>"
+    "    (?P<timesep>T)"  # Separator (T)
+    r"    (?P<hours>\d+(?:[.,]\d+)?H)?"
+    r"    (?P<minutes>\d+(?:[.,]\d+)?M)?"
+    r"    (?P<seconds>\d+(?:[.,]\d+)?S)?"
+    ")?"
+    "$",
+    re.VERBOSE,
+)
+
+
+def parse_timedelta_from_iso_format(text: str) -> timedelta:
+    """Parses a ISO8601 duration string into a timedelta object."""
+
+    m = _ISO8601_DURATION_PATTERN.match(text)
+    if not m:
+        raise ValueError(f"Invalid ISO8601 duration string: {text}")
+
+    weeks = float(m.group("weeks").replace(",", ".").replace("W", "")) if m.group("weeks") else 0
+    years = float(m.group("years").replace(",", ".").replace("Y", "")) if m.group("years") else 0
+    months = float(m.group("months").replace(",", ".").replace("M", "")) if m.group("months") else 0
+    days = float(m.group("days").replace(",", ".").replace("D", "")) if m.group("days") else 0
+    hours = float(m.group("hours").replace(",", ".").replace("H", "")) if m.group("hours") else 0
+    minutes = float(m.group("minutes").replace(",", ".").replace("M", "")
+                    ) if m.group("minutes") else 0
+    seconds = float(m.group("seconds").replace(",", ".").replace("S", "")
+                    ) if m.group("seconds") else 0
+    _have_date = years or months or days
+    _have_time = hours or minutes or seconds
+    if weeks and (_have_date or _have_time):
+        raise ValueError("Combining weeks with other date/time parts is not supported")
+
+    _total_days = (years * 365) + (months * 30) + days
+    return timedelta(
+        days=_total_days,
+        hours=hours,
+        minutes=minutes,
+        seconds=seconds,
+        weeks=weeks,
+    )
+
+_TIMEDELTA_PATTERN = re.compile(
+    r"^(?P<hours>\d+):(?P<minutes>\d+)(?::(?P<seconds>\d+))?$"
+)
+
+def parse_timedelta_string(text: str) -> timedelta:
+    """Checks if a given string is a valid ISO8601 duration string. Or hh:mm:ss format."""
+    try:
+        return parse_timedelta_from_iso_format(text)
+    except ValueError:
+        # The previous library also supported hh:mm:ss format without the need for the P indicator
+        m = _TIMEDELTA_PATTERN.match(text)
+        if not m:
+            raise ValueError(f"Invalid timedelta string: {text}")
+
+        hours = int(m.group("hours"))
+        minutes = int(m.group("minutes"))
+        seconds = int(m.group("seconds") or 0)
+        return timedelta(hours=hours, minutes=minutes, seconds=seconds)
diff --git a/packages/abstractions/kiota_abstractions/utils.py b/packages/abstractions/kiota_abstractions/utils.py
index 4ca2150..8146aa2 100644
--- a/packages/abstractions/kiota_abstractions/utils.py
+++ b/packages/abstractions/kiota_abstractions/utils.py
@@ -1,8 +1,5 @@
 import importlib.util
 import sys
-import re
-from datetime import timedelta
-
 
 def lazy_import(name):
     """Lazily imports a python module given its absolute path.
@@ -40,57 +37,3 @@ def lazy_import(name):
 
     return module
 
-
-_ISO8601_DURATION_PATTERN = re.compile(
-    "^P"  # Duration P indicator
-    # Weeks
-    "(?P<w>"
-    r"    (?P<weeks>\d+(?:[.,]\d+)?W)"
-    ")?"
-    # Years, Months, Days
-    "(?P<ymd>"
-    r"    (?P<years>\d+(?:[.,]\d+)?Y)?"
-    r"    (?P<months>\d+(?:[.,]\d+)?M)?"
-    r"    (?P<days>\d+(?:[.,]\d+)?D)?"
-    ")?"
-    # Time
-    "(?P<hms>"
-    "    (?P<timesep>T)"  # Separator (T)
-    r"    (?P<hours>\d+(?:[.,]\d+)?H)?"
-    r"    (?P<minutes>\d+(?:[.,]\d+)?M)?"
-    r"    (?P<seconds>\d+(?:[.,]\d+)?S)?"
-    ")?"
-    "$",
-    re.VERBOSE,
-)
-
-
-def parse_timedelta_from_iso_format(text: str) -> timedelta:
-    """Parses a ISO8601 duration string into a timedelta object."""
-
-    m = _ISO8601_DURATION_PATTERN.match(text)
-    if not m:
-        raise ValueError(f"Invalid ISO8601 duration string: {text}")
-
-    weeks = float(m.group("weeks").replace(",", ".").replace("W", "")) if m.group("weeks") else 0
-    years = float(m.group("years").replace(",", ".").replace("Y", "")) if m.group("years") else 0
-    months = float(m.group("months").replace(",", ".").replace("M", "")) if m.group("months") else 0
-    days = float(m.group("days").replace(",", ".").replace("D", "")) if m.group("days") else 0
-    hours = float(m.group("hours").replace(",", ".").replace("H", "")) if m.group("hours") else 0
-    minutes = float(m.group("minutes").replace(",", ".").replace("M", "")
-                    ) if m.group("minutes") else 0
-    seconds = float(m.group("seconds").replace(",", ".").replace("S", "")
-                    ) if m.group("seconds") else 0
-    _have_date = years or months or days
-    _have_time = hours or minutes or seconds
-    if weeks and (_have_date or _have_time):
-        raise ValueError("Combining weeks with other date/time parts is not supported")
-
-    _total_days = (years * 365) + (months * 30) + days
-    return timedelta(
-        days=_total_days,
-        hours=hours,
-        minutes=minutes,
-        seconds=seconds,
-        weeks=weeks,
-    )
diff --git a/packages/abstractions/tests/test_utils.py b/packages/abstractions/tests/test_date_utils.py
similarity index 62%
rename from packages/abstractions/tests/test_utils.py
rename to packages/abstractions/tests/test_date_utils.py
index cf2e8a4..1cf15ee 100644
--- a/packages/abstractions/tests/test_utils.py
+++ b/packages/abstractions/tests/test_date_utils.py
@@ -1,6 +1,6 @@
 import pytest
 
-from kiota_abstractions.utils import parse_timedelta_from_iso_format
+from kiota_abstractions.date_utils import parse_timedelta_from_iso_format, parse_timedelta_string
 
 
 def test_parse_timedelta_from_iso_format_weeks():
@@ -43,14 +43,21 @@ def test_parse_timedelta_from_iso_format_days_and_time():
     assert result.days == 3
     assert result.seconds == 10983
 
+def test_parse_timedelta_from_iso_format_time_without_p():
+    result = parse_timedelta_from_iso_format("T3H3M3S")
+    assert result.days == 0
+    assert result.seconds == 10983
+
 
-def test_parse_timedelta_from_iso_format_weeks_and_years():
+@pytest.mark.parametrize("input", ["P3W3Y", "P3W3Y3D", "P3W3Y3DT3H3M3S"])
+def test_parse_timedelta_from_iso_format_must_raise(input: str):
     # assert this raises a ValueError
     with pytest.raises(ValueError):
-        parse_timedelta_from_iso_format("P3W3Y")
+        parse_timedelta_from_iso_format(input)
 
 
-def test_parse_timedelta_from_iso_format_years_and_weeks():
-    # assert this raises a ValueError
-    with pytest.raises(ValueError):
-        parse_timedelta_from_iso_format("P3Y3W")
+@pytest.mark.parametrize("input,expected_hours", [("PT3H", 3), ("2:00:00", 2)])
+def test_parse_timedelta_string_valid(input:str, expected_hours:int):
+    result = parse_timedelta_string(input)
+    assert result.days == 0
+    assert result.seconds == expected_hours * 3600
diff --git a/packages/serialization/form/kiota_serialization_form/form_parse_node.py b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
index 7984b7b..34bd5a8 100644
--- a/packages/serialization/form/kiota_serialization_form/form_parse_node.py
+++ b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
@@ -9,7 +9,7 @@
 from urllib.parse import unquote_plus
 from uuid import UUID
 
-from kiota_abstractions.utils import parse_timedelta_from_iso_format
+from kiota_abstractions.date_utils import parse_timedelta_string
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
@@ -105,7 +105,7 @@ def get_timedelta_value(self) -> Optional[timedelta]:
         """
         if self._node and self._node != "null":
             try:
-                return parse_timedelta_from_iso_format(self._node)
+                return parse_timedelta_string(self._node)
             except:
                 return None
         return None
@@ -312,7 +312,7 @@ def try_get_anything(self, value: Any) -> Any:
             except ValueError:
                 pass
             try:
-                return parse_timedelta_from_iso_format(value)
+                return parse_timedelta_string(value)
             except ValueError:
                 pass
             try:
diff --git a/packages/serialization/json/kiota_serialization_json/json_parse_node.py b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
index a2b2d79..15a66d4 100644
--- a/packages/serialization/json/kiota_serialization_json/json_parse_node.py
+++ b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
@@ -9,7 +9,7 @@
 from typing import Any, Optional, TypeVar
 from uuid import UUID
 
-from kiota_abstractions.utils import parse_timedelta_from_iso_format
+from kiota_abstractions.date_utils import parse_timedelta_string
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
@@ -110,7 +110,7 @@ def get_timedelta_value(self) -> Optional[timedelta]:
             return self._json_node
         if isinstance(self._json_node, str):
             try:
-                return parse_timedelta_from_iso_format(self._json_node)
+                return parse_timedelta_string(self._json_node)
             except ValueError:
                 return None
         return None
@@ -325,7 +325,7 @@ def try_get_anything(self, value: Any) -> Any:
             except:
                 pass
             try:
-                return parse_timedelta_from_iso_format(value)
+                return parse_timedelta_string(value)
             except ValueError:
                 pass
             try:
diff --git a/packages/serialization/json/kiota_serialization_json/json_serialization_writer.py b/packages/serialization/json/kiota_serialization_json/json_serialization_writer.py
index e81644b..ecfdd79 100644
--- a/packages/serialization/json/kiota_serialization_json/json_serialization_writer.py
+++ b/packages/serialization/json/kiota_serialization_json/json_serialization_writer.py
@@ -8,7 +8,7 @@
 from typing import Any, Optional, TypeVar
 from uuid import UUID
 
-from kiota_abstractions.utils import parse_timedelta_from_iso_format
+from kiota_abstractions.date_utils import parse_timedelta_string
 from kiota_abstractions.serialization import Parsable, SerializationWriter
 
 T = TypeVar("T")
@@ -138,7 +138,7 @@ def write_timedelta_value(self, key: Optional[str], value: Optional[timedelta])
                 self.value = str(value)
         elif isinstance(value, str):
             try:
-                parse_timedelta_from_iso_format(value)
+                parse_timedelta_string(value)
                 if key:
                     self.writer[key] = value
                 else:
diff --git a/packages/serialization/text/kiota_serialization_text/text_parse_node.py b/packages/serialization/text/kiota_serialization_text/text_parse_node.py
index 302b3e9..54b4843 100644
--- a/packages/serialization/text/kiota_serialization_text/text_parse_node.py
+++ b/packages/serialization/text/kiota_serialization_text/text_parse_node.py
@@ -7,7 +7,7 @@
 from typing import Optional, TypeVar
 from uuid import UUID
 
-from kiota_abstractions.utils import parse_timedelta_from_iso_format
+from kiota_abstractions.date_utils import parse_timedelta_string
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
@@ -105,7 +105,7 @@ def get_timedelta_value(self) -> Optional[timedelta]:
         """
         datetime_str = self.get_str_value()
         if datetime_str:
-            return parse_timedelta_from_iso_format(datetime_str)
+            return parse_timedelta_string(datetime_str)
         return None
 
     def get_date_value(self) -> Optional[date]:

From 293ea59436141afa9ee19b8f311c6ca308ac143d Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Thu, 16 Jan 2025 12:10:52 +0000
Subject: [PATCH 18/24] Make P mandatory

---
 packages/abstractions/kiota_abstractions/date_utils.py      | 4 ++--
 packages/abstractions/tests/test_date_utils.py              | 6 ++----
 .../serialization/text/tests/unit/test_text_parse_node.py   | 2 +-
 3 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/packages/abstractions/kiota_abstractions/date_utils.py b/packages/abstractions/kiota_abstractions/date_utils.py
index d14dca6..b8c10bd 100644
--- a/packages/abstractions/kiota_abstractions/date_utils.py
+++ b/packages/abstractions/kiota_abstractions/date_utils.py
@@ -3,7 +3,7 @@
 
 
 _ISO8601_DURATION_PATTERN = re.compile(
-    "^P?"  # Duration P indicator (was optional in previous parsing library)
+    "^P"  # Duration P indicator
     # Weeks
     "(?P<w>"
     r"    (?P<weeks>\d+(?:[.,]\d+)?W)"
@@ -65,7 +65,7 @@ def parse_timedelta_string(text: str) -> timedelta:
     try:
         return parse_timedelta_from_iso_format(text)
     except ValueError:
-        # The previous library also supported hh:mm:ss format without the need for the P indicator
+        # The previous library also supported hh:mm:ss format
         m = _TIMEDELTA_PATTERN.match(text)
         if not m:
             raise ValueError(f"Invalid timedelta string: {text}")
diff --git a/packages/abstractions/tests/test_date_utils.py b/packages/abstractions/tests/test_date_utils.py
index 1cf15ee..0875627 100644
--- a/packages/abstractions/tests/test_date_utils.py
+++ b/packages/abstractions/tests/test_date_utils.py
@@ -44,10 +44,8 @@ def test_parse_timedelta_from_iso_format_days_and_time():
     assert result.seconds == 10983
 
 def test_parse_timedelta_from_iso_format_time_without_p():
-    result = parse_timedelta_from_iso_format("T3H3M3S")
-    assert result.days == 0
-    assert result.seconds == 10983
-
+    with pytest.raises(ValueError):
+        parse_timedelta_from_iso_format("T3H3M3S")
 
 @pytest.mark.parametrize("input", ["P3W3Y", "P3W3Y3D", "P3W3Y3DT3H3M3S"])
 def test_parse_timedelta_from_iso_format_must_raise(input: str):
diff --git a/packages/serialization/text/tests/unit/test_text_parse_node.py b/packages/serialization/text/tests/unit/test_text_parse_node.py
index d1a93d1..a389b19 100644
--- a/packages/serialization/text/tests/unit/test_text_parse_node.py
+++ b/packages/serialization/text/tests/unit/test_text_parse_node.py
@@ -80,7 +80,7 @@ def test_get_time_value():
 
 
 def test_get_timedelta_value():
-    parse_node = TextParseNode('T12H59M45S')
+    parse_node = TextParseNode('PT12H59M45S')
     result = parse_node.get_timedelta_value()
     assert isinstance(result, timedelta)
     assert str(result) == '12:59:45'

From 3bea9535d102ff2d7c3e35c610f34ca18729049d Mon Sep 17 00:00:00 2001
From: Vincent Biret <vibiret@microsoft.com>
Date: Thu, 16 Jan 2025 08:07:05 -0500
Subject: [PATCH 19/24] chore: fixes formatting

---
 packages/abstractions/kiota_abstractions/date_utils.py | 7 +++----
 packages/abstractions/kiota_abstractions/utils.py      | 2 +-
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/packages/abstractions/kiota_abstractions/date_utils.py b/packages/abstractions/kiota_abstractions/date_utils.py
index b8c10bd..9a3fc35 100644
--- a/packages/abstractions/kiota_abstractions/date_utils.py
+++ b/packages/abstractions/kiota_abstractions/date_utils.py
@@ -1,7 +1,6 @@
 import re
 from datetime import timedelta
 
-
 _ISO8601_DURATION_PATTERN = re.compile(
     "^P"  # Duration P indicator
     # Weeks
@@ -56,9 +55,9 @@ def parse_timedelta_from_iso_format(text: str) -> timedelta:
         weeks=weeks,
     )
 
-_TIMEDELTA_PATTERN = re.compile(
-    r"^(?P<hours>\d+):(?P<minutes>\d+)(?::(?P<seconds>\d+))?$"
-)
+
+_TIMEDELTA_PATTERN = re.compile(r"^(?P<hours>\d+):(?P<minutes>\d+)(?::(?P<seconds>\d+))?$")
+
 
 def parse_timedelta_string(text: str) -> timedelta:
     """Checks if a given string is a valid ISO8601 duration string. Or hh:mm:ss format."""
diff --git a/packages/abstractions/kiota_abstractions/utils.py b/packages/abstractions/kiota_abstractions/utils.py
index 8146aa2..6e01b84 100644
--- a/packages/abstractions/kiota_abstractions/utils.py
+++ b/packages/abstractions/kiota_abstractions/utils.py
@@ -1,6 +1,7 @@
 import importlib.util
 import sys
 
+
 def lazy_import(name):
     """Lazily imports a python module given its absolute path.
 
@@ -36,4 +37,3 @@ def lazy_import(name):
     loader.exec_module(module)
 
     return module
-

From 8aaeff1e446b3503af46ca6a51261871914fa77a Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Fri, 17 Jan 2025 13:12:27 +0000
Subject: [PATCH 20/24] fromisoformat compatibility

---
 .../kiota_abstractions/date_utils.py          | 48 +++++++++++++++++--
 .../abstractions/tests/test_date_utils.py     | 34 ++++++++++---
 .../form_parse_node.py                        | 12 +++--
 .../json_parse_node.py                        | 12 +++--
 .../text_parse_node.py                        |  8 ++--
 5 files changed, 91 insertions(+), 23 deletions(-)

diff --git a/packages/abstractions/kiota_abstractions/date_utils.py b/packages/abstractions/kiota_abstractions/date_utils.py
index 9a3fc35..1c96549 100644
--- a/packages/abstractions/kiota_abstractions/date_utils.py
+++ b/packages/abstractions/kiota_abstractions/date_utils.py
@@ -1,5 +1,6 @@
+from sys import version_info as sys_version_info
 import re
-from datetime import timedelta
+from datetime import datetime, time, timedelta
 
 _ISO8601_DURATION_PATTERN = re.compile(
     "^P"  # Duration P indicator
@@ -63,13 +64,54 @@ def parse_timedelta_string(text: str) -> timedelta:
     """Checks if a given string is a valid ISO8601 duration string. Or hh:mm:ss format."""
     try:
         return parse_timedelta_from_iso_format(text)
-    except ValueError:
+    except ValueError as exc:
         # The previous library also supported hh:mm:ss format
         m = _TIMEDELTA_PATTERN.match(text)
         if not m:
-            raise ValueError(f"Invalid timedelta string: {text}")
+            raise ValueError(f"Invalid timedelta string: {text}") from exc
 
         hours = int(m.group("hours"))
         minutes = int(m.group("minutes"))
         seconds = int(m.group("seconds") or 0)
         return timedelta(hours=hours, minutes=minutes, seconds=seconds)
+
+
+_TIME_REPLACEMENT_PATTERN = re.compile(r"(\d[.,])(\d+)")
+
+
+def datetime_from_iso_format_compat(text: str) -> datetime:
+    """Parses a ISO8601 formatted string into a datetime object."""
+    try:
+        # Try regular first (faster for most cases)
+        return datetime.fromisoformat(text)
+    except ValueError as exc:
+        # Python 3.10 and below only support fractions of seconds in either 3 or 6 digits
+        # Python 3.11+ supports any number of digits
+
+        if (sys_version_info[:3] <= (3, 10)):
+            # The following code is a workaround for Python 3.10 and below
+            fixed_time = re.sub(
+                _TIME_REPLACEMENT_PATTERN, lambda x: x.group(1) + x.group(2).ljust(6, '0')[:6], text
+            )
+            return datetime.fromisoformat(fixed_time)
+
+        raise exc
+
+
+def time_from_iso_format_compat(text: str) -> time:
+    """Parses a ISO8601 formatted string into a time object."""
+    try:
+        # Try regular first (faster for most cases)
+        return time.fromisoformat(text)
+    except ValueError as exc:
+        # Python 3.10 and below only support fractions of seconds in either 3 or 6 digits
+        # Python 3.11+ supports any number of digits
+
+        if (sys_version_info[:3] <= (3, 10)):
+            # The following code is a workaround for Python 3.10 and below
+            fixed_time = re.sub(
+                _TIME_REPLACEMENT_PATTERN, lambda x: x.group(1) + x.group(2).ljust(6, '0')[:6], text
+            )
+            return time.fromisoformat(fixed_time)
+
+        raise exc
diff --git a/packages/abstractions/tests/test_date_utils.py b/packages/abstractions/tests/test_date_utils.py
index 0875627..455962d 100644
--- a/packages/abstractions/tests/test_date_utils.py
+++ b/packages/abstractions/tests/test_date_utils.py
@@ -1,6 +1,26 @@
 import pytest
 
-from kiota_abstractions.date_utils import parse_timedelta_from_iso_format, parse_timedelta_string
+from kiota_abstractions.date_utils import (
+    parse_timedelta_from_iso_format,
+    parse_timedelta_string,
+    time_from_iso_format_compat,
+    datetime_from_iso_format_compat
+)
+
+
+@pytest.mark.parametrize("text", ["08:00:00", "08:00:00.0", "08:00:00.00", "08:00:00.000", "08:00:00.0000","08:00:00.00000","08:00:00.000000", "08:00:00.0000000", "08:00:00,0000000"])
+def test_time_from_iso_format_compat(text: str):
+    result = time_from_iso_format_compat(text)
+    assert result.hour == 8
+    assert result.minute == 0
+    assert result.second == 0
+
+@pytest.mark.parametrize("text", ["1986-07-28T08:00:00", "1986-07-28T08:00:00.0", "1986-07-28T08:00:00.00", "1986-07-28T08:00:00.000", "1986-07-28T08:00:00.0000","1986-07-28T08:00:00.00000","1986-07-28T08:00:00.000000", "1986-07-28T08:00:00.0000000", "1986-07-28T08:00:00,0000000"])
+def test_datetime_from_iso_format_compat(text: str):
+    result = datetime_from_iso_format_compat(text)
+    assert result.hour == 8
+    assert result.minute == 0
+    assert result.second == 0
 
 
 def test_parse_timedelta_from_iso_format_weeks():
@@ -47,15 +67,15 @@ def test_parse_timedelta_from_iso_format_time_without_p():
     with pytest.raises(ValueError):
         parse_timedelta_from_iso_format("T3H3M3S")
 
-@pytest.mark.parametrize("input", ["P3W3Y", "P3W3Y3D", "P3W3Y3DT3H3M3S"])
-def test_parse_timedelta_from_iso_format_must_raise(input: str):
+@pytest.mark.parametrize("text", ["P3W3Y", "P3W3Y3D", "P3W3Y3DT3H3M3S"])
+def test_parse_timedelta_from_iso_format_must_raise(text: str):
     # assert this raises a ValueError
     with pytest.raises(ValueError):
-        parse_timedelta_from_iso_format(input)
+        parse_timedelta_from_iso_format(text)
 
 
-@pytest.mark.parametrize("input,expected_hours", [("PT3H", 3), ("2:00:00", 2)])
-def test_parse_timedelta_string_valid(input:str, expected_hours:int):
-    result = parse_timedelta_string(input)
+@pytest.mark.parametrize("text, expected_hours", [("PT3H", 3), ("2:00:00", 2)])
+def test_parse_timedelta_string_valid(text:str, expected_hours:int):
+    result = parse_timedelta_string(text)
     assert result.days == 0
     assert result.seconds == expected_hours * 3600
diff --git a/packages/serialization/form/kiota_serialization_form/form_parse_node.py b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
index 34bd5a8..6f5bc5f 100644
--- a/packages/serialization/form/kiota_serialization_form/form_parse_node.py
+++ b/packages/serialization/form/kiota_serialization_form/form_parse_node.py
@@ -9,7 +9,9 @@
 from urllib.parse import unquote_plus
 from uuid import UUID
 
-from kiota_abstractions.date_utils import parse_timedelta_string
+from kiota_abstractions.date_utils import (
+    parse_timedelta_string, datetime_from_iso_format_compat, time_from_iso_format_compat
+)
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
@@ -93,7 +95,7 @@ def get_datetime_value(self) -> Optional[datetime]:
         """
         if self._node and self._node != "null":
             try:
-                return datetime.fromisoformat(self._node)
+                return datetime_from_iso_format_compat(self._node)
             except:
                 return None
         return None
@@ -129,7 +131,7 @@ def get_time_value(self) -> Optional[time]:
         """
         if self._node and self._node != "null":
             try:
-                return time.fromisoformat(self._node)
+                return time_from_iso_format_compat(self._node)
             except:
                 return None
         return None
@@ -303,7 +305,7 @@ def try_get_anything(self, value: Any) -> Any:
             return dict(map(lambda x: (x[0], self.try_get_anything(x[1])), value.items()))
         if isinstance(value, str):
             try:
-                datetime_obj = datetime.fromisoformat(value)
+                datetime_obj = datetime_from_iso_format_compat(value)
                 return datetime_obj
             except ValueError:
                 pass
@@ -320,7 +322,7 @@ def try_get_anything(self, value: Any) -> Any:
             except ValueError:
                 pass
             try:
-                return time.fromisoformat(value)
+                return time_from_iso_format_compat(value)
             except ValueError:
                 pass
             return value
diff --git a/packages/serialization/json/kiota_serialization_json/json_parse_node.py b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
index 15a66d4..f560319 100644
--- a/packages/serialization/json/kiota_serialization_json/json_parse_node.py
+++ b/packages/serialization/json/kiota_serialization_json/json_parse_node.py
@@ -9,7 +9,9 @@
 from typing import Any, Optional, TypeVar
 from uuid import UUID
 
-from kiota_abstractions.date_utils import parse_timedelta_string
+from kiota_abstractions.date_utils import (
+    parse_timedelta_string, datetime_from_iso_format_compat, time_from_iso_format_compat
+)
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
@@ -96,7 +98,7 @@ def get_datetime_value(self) -> Optional[datetime]:
             if len(self._json_node) < 10:
                 return None
 
-            datetime_obj = datetime.fromisoformat(self._json_node)
+            datetime_obj = datetime_from_iso_format_compat(self._json_node)
             if isinstance(datetime_obj, datetime):
                 return datetime_obj
         return None
@@ -136,7 +138,7 @@ def get_time_value(self) -> Optional[time]:
         if isinstance(self._json_node, time):
             return self._json_node
         if isinstance(self._json_node, str):
-            datetime_obj = time.fromisoformat(self._json_node)
+            datetime_obj = time_from_iso_format_compat(self._json_node)
             if isinstance(datetime_obj, time):
                 return datetime_obj
         return None
@@ -316,7 +318,7 @@ def try_get_anything(self, value: Any) -> Any:
                     return value
                 if value.isdigit():
                     return value
-                datetime_obj = datetime.fromisoformat(value)
+                datetime_obj = datetime_from_iso_format_compat(value)
                 return datetime_obj
             except ValueError:
                 pass
@@ -333,7 +335,7 @@ def try_get_anything(self, value: Any) -> Any:
             except ValueError:
                 pass
             try:
-                return time.fromisoformat(value)
+                return time_from_iso_format_compat(value)
             except ValueError:
                 pass
             return value
diff --git a/packages/serialization/text/kiota_serialization_text/text_parse_node.py b/packages/serialization/text/kiota_serialization_text/text_parse_node.py
index 54b4843..caf21cd 100644
--- a/packages/serialization/text/kiota_serialization_text/text_parse_node.py
+++ b/packages/serialization/text/kiota_serialization_text/text_parse_node.py
@@ -7,7 +7,9 @@
 from typing import Optional, TypeVar
 from uuid import UUID
 
-from kiota_abstractions.date_utils import parse_timedelta_string
+from kiota_abstractions.date_utils import (
+    parse_timedelta_string, datetime_from_iso_format_compat, time_from_iso_format_compat
+)
 from kiota_abstractions.serialization import Parsable, ParsableFactory, ParseNode
 
 T = TypeVar("T", bool, str, int, float, UUID, datetime, timedelta, date, time, bytes)
@@ -95,7 +97,7 @@ def get_datetime_value(self) -> Optional[datetime]:
         """
         datetime_str = self.get_str_value()
         if datetime_str:
-            return datetime.fromisoformat(datetime_str)
+            return datetime_from_iso_format_compat(datetime_str)
         return None
 
     def get_timedelta_value(self) -> Optional[timedelta]:
@@ -125,7 +127,7 @@ def get_time_value(self) -> Optional[time]:
         """
         datetime_str = self.get_str_value()
         if datetime_str:
-            return time.fromisoformat(datetime_str)
+            return time_from_iso_format_compat(datetime_str)
         return None
 
     def get_collection_of_primitive_values(self, primitive_type: type[T]) -> list[T]:

From 190f9ddd8a19522b0c315126ebdadde5256273a8 Mon Sep 17 00:00:00 2001
From: Vincent Biret <vibiret@microsoft.com>
Date: Fri, 17 Jan 2025 09:03:41 -0500
Subject: [PATCH 21/24] chore: linting

---
 packages/abstractions/kiota_abstractions/date_utils.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/abstractions/kiota_abstractions/date_utils.py b/packages/abstractions/kiota_abstractions/date_utils.py
index 1c96549..d916903 100644
--- a/packages/abstractions/kiota_abstractions/date_utils.py
+++ b/packages/abstractions/kiota_abstractions/date_utils.py
@@ -88,7 +88,7 @@ def datetime_from_iso_format_compat(text: str) -> datetime:
         # Python 3.10 and below only support fractions of seconds in either 3 or 6 digits
         # Python 3.11+ supports any number of digits
 
-        if (sys_version_info[:3] <= (3, 10)):
+        if sys_version_info[:3] <= (3, 10):
             # The following code is a workaround for Python 3.10 and below
             fixed_time = re.sub(
                 _TIME_REPLACEMENT_PATTERN, lambda x: x.group(1) + x.group(2).ljust(6, '0')[:6], text
@@ -107,7 +107,7 @@ def time_from_iso_format_compat(text: str) -> time:
         # Python 3.10 and below only support fractions of seconds in either 3 or 6 digits
         # Python 3.11+ supports any number of digits
 
-        if (sys_version_info[:3] <= (3, 10)):
+        if sys_version_info[:3] <= (3, 10):
             # The following code is a workaround for Python 3.10 and below
             fixed_time = re.sub(
                 _TIME_REPLACEMENT_PATTERN, lambda x: x.group(1) + x.group(2).ljust(6, '0')[:6], text

From 15b5a31686fc31552e47889054ed289ff0dddb23 Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Fri, 17 Jan 2025 14:52:52 +0000
Subject: [PATCH 22/24] =?UTF-8?q?Hopefully=20try=2050=20fixes=20it=20?=
 =?UTF-8?q?=F0=9F=92=A3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../abstractions/kiota_abstractions/date_utils.py    | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/packages/abstractions/kiota_abstractions/date_utils.py b/packages/abstractions/kiota_abstractions/date_utils.py
index d916903..ea33af4 100644
--- a/packages/abstractions/kiota_abstractions/date_utils.py
+++ b/packages/abstractions/kiota_abstractions/date_utils.py
@@ -76,7 +76,7 @@ def parse_timedelta_string(text: str) -> timedelta:
         return timedelta(hours=hours, minutes=minutes, seconds=seconds)
 
 
-_TIME_REPLACEMENT_PATTERN = re.compile(r"(\d[.,])(\d+)")
+_TIME_REPLACEMENT_PATTERN = re.compile(r'(\d)([.,])(\d+)')
 
 
 def datetime_from_iso_format_compat(text: str) -> datetime:
@@ -88,10 +88,11 @@ def datetime_from_iso_format_compat(text: str) -> datetime:
         # Python 3.10 and below only support fractions of seconds in either 3 or 6 digits
         # Python 3.11+ supports any number of digits
 
-        if sys_version_info[:3] <= (3, 10):
+        if sys_version_info[:3] < (3, 11):
             # The following code is a workaround for Python 3.10 and below
             fixed_time = re.sub(
-                _TIME_REPLACEMENT_PATTERN, lambda x: x.group(1) + x.group(2).ljust(6, '0')[:6], text
+                _TIME_REPLACEMENT_PATTERN,
+                lambda x: x.group(1) + "." + x.group(3).ljust(6, '0')[:6], text
             )
             return datetime.fromisoformat(fixed_time)
 
@@ -107,10 +108,11 @@ def time_from_iso_format_compat(text: str) -> time:
         # Python 3.10 and below only support fractions of seconds in either 3 or 6 digits
         # Python 3.11+ supports any number of digits
 
-        if sys_version_info[:3] <= (3, 10):
+        if sys_version_info[:3] < (3, 11):
             # The following code is a workaround for Python 3.10 and below
             fixed_time = re.sub(
-                _TIME_REPLACEMENT_PATTERN, lambda x: x.group(1) + x.group(2).ljust(6, '0')[:6], text
+                _TIME_REPLACEMENT_PATTERN,
+                lambda x: x.group(1) + "." + x.group(3).ljust(6, '0')[:6], text
             )
             return time.fromisoformat(fixed_time)
 

From 1373232d4a84a9bb44fddf1606e5accc38080054 Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Fri, 17 Jan 2025 15:09:15 +0000
Subject: [PATCH 23/24] =?UTF-8?q?More=20=F0=9F=95=91=20compatibility?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 packages/abstractions/kiota_abstractions/date_utils.py | 4 ++--
 packages/abstractions/tests/test_date_utils.py         | 9 +++++++--
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/packages/abstractions/kiota_abstractions/date_utils.py b/packages/abstractions/kiota_abstractions/date_utils.py
index ea33af4..05e9572 100644
--- a/packages/abstractions/kiota_abstractions/date_utils.py
+++ b/packages/abstractions/kiota_abstractions/date_utils.py
@@ -93,7 +93,7 @@ def datetime_from_iso_format_compat(text: str) -> datetime:
             fixed_time = re.sub(
                 _TIME_REPLACEMENT_PATTERN,
                 lambda x: x.group(1) + "." + x.group(3).ljust(6, '0')[:6], text
-            )
+            ).replace("Z", "+00:00")
             return datetime.fromisoformat(fixed_time)
 
         raise exc
@@ -113,7 +113,7 @@ def time_from_iso_format_compat(text: str) -> time:
             fixed_time = re.sub(
                 _TIME_REPLACEMENT_PATTERN,
                 lambda x: x.group(1) + "." + x.group(3).ljust(6, '0')[:6], text
-            )
+            ).replace("Z", "+00:00")
             return time.fromisoformat(fixed_time)
 
         raise exc
diff --git a/packages/abstractions/tests/test_date_utils.py b/packages/abstractions/tests/test_date_utils.py
index 455962d..640a239 100644
--- a/packages/abstractions/tests/test_date_utils.py
+++ b/packages/abstractions/tests/test_date_utils.py
@@ -8,14 +8,19 @@
 )
 
 
-@pytest.mark.parametrize("text", ["08:00:00", "08:00:00.0", "08:00:00.00", "08:00:00.000", "08:00:00.0000","08:00:00.00000","08:00:00.000000", "08:00:00.0000000", "08:00:00,0000000"])
+@pytest.mark.parametrize("text", ["08:00:00", "08:00:00.0", "08:00:00.00","08:00:00.000",
+                                  "08:00:00.0000","08:00:00.00000","08:00:00.000000", "08:00:00.0000000", "08:00:00,0000000",
+                                  "08:00:00,0000000Z", "08:00:00.00Z", "08:00:00.00+00:00" ])
 def test_time_from_iso_format_compat(text: str):
     result = time_from_iso_format_compat(text)
     assert result.hour == 8
     assert result.minute == 0
     assert result.second == 0
 
-@pytest.mark.parametrize("text", ["1986-07-28T08:00:00", "1986-07-28T08:00:00.0", "1986-07-28T08:00:00.00", "1986-07-28T08:00:00.000", "1986-07-28T08:00:00.0000","1986-07-28T08:00:00.00000","1986-07-28T08:00:00.000000", "1986-07-28T08:00:00.0000000", "1986-07-28T08:00:00,0000000"])
+@pytest.mark.parametrize("text", ["1986-07-28T08:00:00", "1986-07-28T08:00:00.0", "1986-07-28T08:00:00.00",
+                                  "1986-07-28T08:00:00.000", "1986-07-28T08:00:00.0000", "1986-07-28T08:00:00.00000",
+                                  "1986-07-28T08:00:00.000000", "1986-07-28T08:00:00.0000000", "1986-07-28T08:00:00,0000000",
+                                  "1986-07-28T08:00:00.0000000Z", "1986-07-28T08:00:00.00Z", "1986-07-28T08:00:00.00+00:00" ])
 def test_datetime_from_iso_format_compat(text: str):
     result = datetime_from_iso_format_compat(text)
     assert result.hour == 8

From f1b515fe9c0b539caa24a6caeda03f9fbe7eb5d6 Mon Sep 17 00:00:00 2001
From: Stephan van Rooij <1292510+svrooij@users.noreply.github.com>
Date: Fri, 17 Jan 2025 15:21:23 +0000
Subject: [PATCH 24/24] =?UTF-8?q?Fixing=20datetime=20parsing=20in=20test?=
 =?UTF-8?q?=20=F0=9F=A7=AA?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 packages/serialization/json/tests/unit/test_json_parse_node.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packages/serialization/json/tests/unit/test_json_parse_node.py b/packages/serialization/json/tests/unit/test_json_parse_node.py
index 3ca619d..21ea6a0 100644
--- a/packages/serialization/json/tests/unit/test_json_parse_node.py
+++ b/packages/serialization/json/tests/unit/test_json_parse_node.py
@@ -160,7 +160,8 @@ def test_get_anythin_does_convert_date_string_to_datetime():
     parse_node = JsonParseNode("2023-10-05T14:48:00.000Z")
     result = parse_node.try_get_anything("2023-10-05T14:48:00.000Z")
     assert isinstance(result, datetime)
-    assert result == datetime.fromisoformat("2023-10-05T14:48:00.000Z")
+    # there is an issue with parsing the original iso string (Z not supported < 3.11)
+    assert result == datetime(2023, 10, 5, 14, 48, tzinfo=timezone.utc)
 
 
 def test_get_object_value(user1_json):