infrahub-server 1.2.0rc0__py3-none-any.whl → 1.2.2__py3-none-any.whl

infrahub_sdk/timestamp.py

@@ -1,9 +1,15 @@
 from __future__ import annotations
 
 import re
+import warnings
+from datetime import datetime, timezone
+from typing import Literal
 
-import pendulum
-from pendulum.datetime import DateTime
+from whenever import Date, Instant, LocalDateTime, OffsetDateTime, Time, ZonedDateTime
+
+from .exceptions import TimestampFormatError
+
+UTC = timezone.utc  # Required for older versions of Python
 
 REGEX_MAPPING = {
     "seconds": r"(\d+)(s|sec|second|seconds)",
@@ -12,80 +18,183 @@ REGEX_MAPPING = {
 }
 
 
-class TimestampFormatError(ValueError): ...
-
-
 class Timestamp:
-    def __init__(self, value: str | DateTime | Timestamp | None = None):
-        if value and isinstance(value, DateTime):
-            self.obj = value
+    _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
+            self._obj = value._obj
         elif isinstance(value, str):
-            self.obj = self._parse_string(value)
+            self._obj = self._parse_string(value)
         else:
-            self.obj = DateTime.now(tz="UTC")
+            self._obj = ZonedDateTime.now("UTC").round(unit="microsecond")
+
+    @property
+    def obj(self) -> ZonedDateTime:
+        warnings.warn(
+            "Direct access to obj property is deprecated. Use to_string(), to_timestamp(), or to_datetime() instead.",
+            UserWarning,
+            stacklevel=2,
+        )
+        return self._obj
 
     @classmethod
-    def _parse_string(cls, value: str) -> DateTime:
+    def _parse_string(cls, value: str) -> ZonedDateTime:
+        try:
+            zoned_date = ZonedDateTime.parse_common_iso(value)
+            return zoned_date
+        except ValueError:
+            pass
+
+        try:
+            instant_date = Instant.parse_common_iso(value)
+            return instant_date.to_tz("UTC")
+        except ValueError:
+            pass
+
+        try:
+            local_date_time = LocalDateTime.parse_common_iso(value)
+            return local_date_time.assume_utc().to_tz("UTC")
+        except ValueError:
+            pass
+
         try:
-            parsed_date = pendulum.parse(value)
-            if isinstance(parsed_date, DateTime):
-                return parsed_date
-        except (pendulum.parsing.exceptions.ParserError, ValueError):
+            offset_date_time = OffsetDateTime.parse_common_iso(value)
+            return offset_date_time.to_tz("UTC")
+        except ValueError:
             pass
 
-        params = {}
+        try:
+            date = Date.parse_common_iso(value)
+            local_date = date.at(Time(12, 00))
+            return local_date.assume_tz("UTC", disambiguate="compatible")
+        except ValueError:
+            pass
+
+        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}")
+        if params:
+            return ZonedDateTime.now("UTC").subtract(**params)  # type: ignore[call-overload]
 
-        return DateTime.now(tz="UTC").subtract(**params)
+        raise TimestampFormatError(f"Invalid time format for {value}")
 
     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":
-            iso8601_string = iso8601_string[:-1] + "+00:00"
-        return iso8601_string
+        time_str = self.to_datetime().isoformat(timespec="microseconds")
+        if with_z and time_str.endswith("+00:00"):
+            time_str = time_str[:-6]
+            time_str += "Z"
+        return time_str
 
     def to_timestamp(self) -> int:
-        return self.obj.int_timestamp
+        return self._obj.timestamp()
+
+    def to_datetime(self) -> datetime:
+        return self._obj.py_datetime()
+
+    def get_obj(self) -> ZonedDateTime:
+        return self._obj
 
     def __eq__(self, other: object) -> bool:
         if not isinstance(other, Timestamp):
             return NotImplemented
-        return self.obj == other.obj
+        return self._obj == other._obj
 
     def __lt__(self, other: object) -> bool:
         if not isinstance(other, Timestamp):
             return NotImplemented
-        return self.obj < other.obj
+        return self._obj < other._obj
 
     def __gt__(self, other: object) -> bool:
         if not isinstance(other, Timestamp):
             return NotImplemented
-        return self.obj > other.obj
+        return self._obj > other._obj
 
     def __le__(self, other: object) -> bool:
         if not isinstance(other, Timestamp):
             return NotImplemented
-        return self.obj <= other.obj
+        return self._obj <= other._obj
 
     def __ge__(self, other: object) -> bool:
         if not isinstance(other, Timestamp):
             return NotImplemented
-        return self.obj >= other.obj
+        return self._obj >= other._obj
 
     def __hash__(self) -> int:
         return hash(self.to_string())
 
     def add_delta(self, hours: int = 0, minutes: int = 0, seconds: int = 0, microseconds: int = 0) -> Timestamp:
-        time = self.obj.add(hours=hours, minutes=minutes, seconds=seconds, microseconds=microseconds)
-        return Timestamp(time)
+        warnings.warn(
+            "add_delta() is deprecated. Use add() instead.",
+            UserWarning,
+            stacklevel=2,
+        )
+        return self.add(hours=hours, minutes=minutes, seconds=seconds, microseconds=microseconds)
+
+    def add(
+        self,
+        years: int = 0,
+        months: int = 0,
+        weeks: int = 0,
+        days: int = 0,
+        hours: float = 0,
+        minutes: float = 0,
+        seconds: float = 0,
+        milliseconds: float = 0,
+        microseconds: float = 0,
+        nanoseconds: int = 0,
+        disambiguate: Literal["compatible"] = "compatible",
+    ) -> Timestamp:
+        return Timestamp(
+            self._obj.add(
+                years=years,
+                months=months,
+                weeks=weeks,
+                days=days,
+                hours=hours,
+                minutes=minutes,
+                seconds=seconds,
+                milliseconds=milliseconds,
+                microseconds=microseconds,
+                nanoseconds=nanoseconds,
+                disambiguate=disambiguate,
+            )
+        )
+
+    def subtract(
+        self,
+        years: int = 0,
+        months: int = 0,
+        weeks: int = 0,
+        days: int = 0,
+        hours: float = 0,
+        minutes: float = 0,
+        seconds: float = 0,
+        milliseconds: float = 0,
+        microseconds: float = 0,
+        nanoseconds: int = 0,
+        disambiguate: Literal["compatible"] = "compatible",
+    ) -> Timestamp:
+        return Timestamp(
+            self._obj.subtract(
+                years=years,
+                months=months,
+                weeks=weeks,
+                days=days,
+                hours=hours,
+                minutes=minutes,
+                seconds=seconds,
+                milliseconds=milliseconds,
+                microseconds=microseconds,
+                nanoseconds=nanoseconds,
+                disambiguate=disambiguate,
+            )
+        )

infrahub_sdk/utils.py

@@ -17,10 +17,12 @@ from graphql import (
 
 from infrahub_sdk.repository import GitRepoManager
 
-from .exceptions import FileNotValidError, JsonDecodeError
+from .exceptions import FileNotValidError, JsonDecodeError, TimestampFormatError
+from .timestamp import Timestamp
 
 if TYPE_CHECKING:
     from graphql import GraphQLResolveInfo
+    from whenever import TimeDelta
 
 
 def base36encode(number: int) -> str:
@@ -367,3 +369,29 @@ 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().get_obj().difference(time_value.get_obj())
+    (hrs, mins, secs, nanos) = delta.in_hrs_mins_secs_nanos()
+
+    if nanos and nanos > 500_000_000:
+        secs += 1
+
+    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"

{infrahub_server-1.2.0rc0.dist-info → infrahub_server-1.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: infrahub-server
-Version: 1.2.0rc0
+Version: 1.2.2
 Summary: Infrahub is taking a new approach to Infrastructure Management by providing a new generation of datastore to organize and control all the data that defines how an infrastructure should run.
 Home-page: https://opsmill.com
 License: AGPL-3.0-only
@@ -29,8 +29,8 @@ Requires-Dist: graphene (>=3.4,<3.5)
 Requires-Dist: gunicorn (>=23.0.0,<24.0.0)
 Requires-Dist: lunr (>=0.7.0.post1,<0.8.0)
 Requires-Dist: nats-py (>=2.7.2,<3.0.0)
-Requires-Dist: neo4j (>=5.27,<5.28)
-Requires-Dist: neo4j-rust-ext (>=5.27.0.0,<6.0.0.0)
+Requires-Dist: neo4j (>=5.28,<5.29)
+Requires-Dist: neo4j-rust-ext (>=5.28,<5.29)
 Requires-Dist: netaddr (==1.3.0)
 Requires-Dist: numpy (>=1.24.2,<2.0.0) ; python_version >= "3.9" and python_version < "3.12"
 Requires-Dist: numpy (>=1.26.2,<2.0.0) ; python_version >= "3.12"
@@ -38,10 +38,11 @@ Requires-Dist: opentelemetry-exporter-otlp-proto-grpc (==1.28.1)
 Requires-Dist: opentelemetry-exporter-otlp-proto-http (==1.28.1)
 Requires-Dist: opentelemetry-instrumentation-aio-pika (==0.49b1)
 Requires-Dist: opentelemetry-instrumentation-fastapi (==0.49b1)
-Requires-Dist: prefect (==3.1.14)
+Requires-Dist: prefect (==3.2.11)
+Requires-Dist: prefect-redis (==0.2.2)
 Requires-Dist: pyarrow (>=14,<15)
-Requires-Dist: pydantic (>=2.9,<2.10)
-Requires-Dist: pydantic-settings (>=2.7,<2.8)
+Requires-Dist: pydantic (>=2.10,<2.11)
+Requires-Dist: pydantic-settings (>=2.8,<2.9)
 Requires-Dist: pyjwt (>=2.8,<2.9)
 Requires-Dist: pytest (>=7.4,<7.5)
 Requires-Dist: python-multipart (==0.0.18)
@@ -54,6 +55,7 @@ Requires-Dist: toml (>=0.10,<0.11)
 Requires-Dist: typer (==0.12.5)
 Requires-Dist: ujson (>=5,<6)
 Requires-Dist: uvicorn[standard] (>=0.32,<0.33)
+Requires-Dist: whenever (==0.7.2)
 Project-URL: Documentation, https://docs.infrahub.app/
 Project-URL: Repository, https://github.com/opsmill/infrahub
 Description-Content-Type: text/markdown