Replace pendulum with whenever

Author: dgarros

infrahub_sdk/ctl/branch.py

@@ -5,9 +5,10 @@
 from rich.table import Table
 
 from ..async_typer import AsyncTyper
-from ..ctl.client import initialize_client
-from ..ctl.utils import calculate_time_diff, catch_exception
+from ..utils import calculate_time_diff
+from .client import initialize_client
 from .parameters import CONFIG_PARAM
+from .utils import catch_exception
 
 app = AsyncTyper()
 console = Console()

infrahub_sdk/ctl/utils.py

@@ -8,11 +8,9 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable, NoReturn, TypeVar
 
-import pendulum
 import typer
 from click.exceptions import Exit
 from httpx import HTTPError
-from pendulum.datetime import DateTime
 from rich.console import Console
 from rich.logging import RichHandler
 from rich.markup import escape
@@ -151,20 +149,6 @@ def parse_cli_vars(variables: list[str] | None) -> dict[str, str]:
     return {var.split("=")[0]: var.split("=")[1] for var in variables if "=" in var}
 
 
-def calculate_time_diff(value: str) -> str | None:
-    """Calculate the time in human format between a timedate in string format and now."""
-    try:
-        time_value = pendulum.parse(value)
-    except pendulum.parsing.exceptions.ParserError:
-        return None
-
-    if not isinstance(time_value, DateTime):
-        return None
-
-    pendulum.set_locale("en")
-    return time_value.diff_for_humans(other=pendulum.now(), absolute=True)
-
-
 def find_graphql_query(name: str, directory: str | Path = ".") -> str:
     if isinstance(directory, str):
         directory = Path(directory)

infrahub_sdk/timestamp.py

@@ -2,8 +2,7 @@
 
 import re
 
-import pendulum
-from pendulum.datetime import DateTime
+from whenever import Instant, ZonedDateTime
 
 REGEX_MAPPING = {
     "seconds": r"(\d+)(s|sec|second|seconds)",
@@ -16,47 +15,58 @@ class TimestampFormatError(ValueError): ...
 
 
 class Timestamp:
-    def __init__(self, value: str | DateTime | Timestamp | None = None):
-        if value and isinstance(value, DateTime):
+    obj: ZonedDateTime
+
+    def __init__(self, value: str | ZonedDateTime | Timestamp | None = None):
+        if value and isinstance(value, ZonedDateTime):
             self.obj = value
         elif value and isinstance(value, self.__class__):
             self.obj = value.obj
         elif isinstance(value, str):
             self.obj = self._parse_string(value)
         else:
-            self.obj = DateTime.now(tz="UTC")
+            self.obj = ZonedDateTime.now("UTC")
 
     @classmethod
-    def _parse_string(cls, value: str) -> DateTime:
+    def _parse_string(cls, value: str) -> ZonedDateTime:
         try:
-            parsed_date = pendulum.parse(value)
-            if isinstance(parsed_date, DateTime):
+            parsed_date = ZonedDateTime.parse_common_iso(value)
+            if isinstance(parsed_date, ZonedDateTime):
                 return parsed_date
-        except (pendulum.parsing.exceptions.ParserError, ValueError):
+        except ValueError:
+            pass
+
+        try:
+            parsed_date_instant = Instant.parse_common_iso(value)
+            if isinstance(parsed_date_instant, Instant):
+                return parsed_date_instant.to_tz("UTC")
+        except ValueError:
             pass
 
-        params = {}
+        params: dict[str, float] = {}
         for key, regex in REGEX_MAPPING.items():
             match = re.search(regex, value)
             if match:
-                params[key] = int(match.group(1))
+                params[key] = float(match.group(1))
 
         if not params:
             raise TimestampFormatError(f"Invalid time format for {value}")
 
-        return DateTime.now(tz="UTC").subtract(**params)
+        return ZonedDateTime.now("UTC").subtract(**params)  # type: ignore[call-overload]
 
     def __repr__(self) -> str:
         return f"Timestamp: {self.to_string()}"
 
     def to_string(self, with_z: bool = True) -> str:
-        iso8601_string = self.obj.to_iso8601_string()
-        if not with_z and iso8601_string[-1] == "Z":
+        if with_z:
+            return self.obj.instant().format_common_iso()
+        iso8601_string = self.obj.format_common_iso()
+        if iso8601_string[-1] == "Z":
             iso8601_string = iso8601_string[:-1] + "+00:00"
         return iso8601_string
 
     def to_timestamp(self) -> int:
-        return self.obj.int_timestamp
+        return self.obj.timestamp()
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Timestamp):

infrahub_sdk/utils.py

@@ -18,9 +18,11 @@
 from infrahub_sdk.repository import GitRepoManager
 
 from .exceptions import JsonDecodeError
+from .timestamp import Timestamp, TimestampFormatError
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
+    from whenever import TimeDelta
 
 
 def base36encode(number: int) -> str:
@@ -357,3 +359,26 @@ def get_user_permissions(data: list[dict]) -> dict:
         groups[group_name] = permissions
 
     return groups
+
+
+def calculate_time_diff(value: str) -> str | None:
+    """Calculate the time in human format between a timedate in string format and now."""
+    try:
+        time_value = Timestamp(value)
+    except TimestampFormatError:
+        return None
+
+    delta: TimeDelta = Timestamp().obj.difference(time_value.obj)
+    (hrs, mins, secs, _) = delta.in_hrs_mins_secs_nanos()
+
+    if hrs and hrs < 24 and mins:
+        return f"{hrs}h {mins}m and {secs}s ago"
+    if hrs and hrs > 24:
+        remaining_hrs = hrs % 24
+        days = int((hrs - remaining_hrs) / 24)
+        return f"{days}d and {remaining_hrs}h ago"
+    if hrs == 0 and mins and secs:
+        return f"{mins}m and {secs}s ago"
+    if hrs == 0 and mins == 0 and secs:
+        return f"{secs}s ago"
+    return "now"