infrahub-server 1.6.0b0__py3-none-any.whl → 1.6.2__py3-none-any.whl

infrahub_sdk/node/node.py

@@ -7,7 +7,14 @@ from typing import TYPE_CHECKING, Any
 from ..constants import InfrahubClientMode
 from ..exceptions import FeatureNotSupportedError, NodeNotFoundError, ResourceNotDefinedError, SchemaNotFoundError
 from ..graphql import Mutation, Query
-from ..schema import GenericSchemaAPI, RelationshipCardinality, RelationshipKind
+from ..schema import (
+    GenericSchemaAPI,
+    ProfileSchemaAPI,
+    RelationshipCardinality,
+    RelationshipKind,
+    RelationshipSchemaAPI,
+    TemplateSchemaAPI,
+)
 from ..utils import compare_lists, generate_short_id
 from .attribute import Attribute
 from .constants import (
@@ -56,9 +63,20 @@ class InfrahubNodeBase:
         self._attributes = [item.name for item in self._schema.attributes]
         self._relationships = [item.name for item in self._schema.relationships]
 
-        self._artifact_support = hasattr(schema, "inherit_from") and "CoreArtifactTarget" in schema.inherit_from
+        # GenericSchemaAPI doesn't have inherit_from, so we need to check the type first
+        if isinstance(schema, GenericSchemaAPI):
+            self._artifact_support = False
+        else:
+            inherit_from = getattr(schema, "inherit_from", None) or []
+            self._artifact_support = "CoreArtifactTarget" in inherit_from
         self._artifact_definition_support = schema.kind == "CoreArtifactDefinition"
 
+        # Check if this node is hierarchical (supports parent/children and ancestors/descendants)
+        if not isinstance(schema, (ProfileSchemaAPI, GenericSchemaAPI, TemplateSchemaAPI)):
+            self._hierarchy_support = getattr(schema, "hierarchy", None) is not None
+        else:
+            self._hierarchy_support = False
+
         if not self.id:
             self._existing = False
 
@@ -384,6 +402,10 @@ class InfrahubNodeBase:
         if not self._artifact_support:
             raise FeatureNotSupportedError(message)
 
+    def _validate_hierarchy_support(self, message: str) -> None:
+        if not self._hierarchy_support:
+            raise FeatureNotSupportedError(message)
+
     def _validate_artifact_definition_support(self, message: str) -> None:
         if not self._artifact_definition_support:
             raise FeatureNotSupportedError(message)
@@ -479,6 +501,7 @@ class InfrahubNode(InfrahubNodeBase):
 
         self._relationship_cardinality_many_data: dict[str, RelationshipManager] = {}
         self._relationship_cardinality_one_data: dict[str, RelatedNode] = {}
+        self._hierarchical_data: dict[str, RelatedNode | RelationshipManager] = {}
 
         super().__init__(schema=schema, branch=branch or client.default_branch, data=data)
 
@@ -532,6 +555,75 @@ class InfrahubNode(InfrahubNodeBase):
                     schema=rel_schema,
                     data=rel_data,
                 )
+        # Initialize parent, children, ancestors and descendants for hierarchical nodes
+        if self._hierarchy_support:
+            # Create pseudo-schema for parent (cardinality one)
+            parent_schema = RelationshipSchemaAPI(
+                name="parent",
+                peer=self._schema.hierarchy,  # type: ignore[union-attr, arg-type]
+                kind=RelationshipKind.HIERARCHY,
+                cardinality="one",
+                optional=True,
+            )
+            parent_data = data.get("parent", None) if isinstance(data, dict) else None
+            self._hierarchical_data["parent"] = RelatedNode(
+                name="parent",
+                client=self._client,
+                branch=self._branch,
+                schema=parent_schema,
+                data=parent_data,
+            )
+            # Create pseudo-schema for children (many cardinality)
+            children_schema = RelationshipSchemaAPI(
+                name="children",
+                peer=self._schema.hierarchy,  # type: ignore[union-attr, arg-type]
+                kind=RelationshipKind.HIERARCHY,
+                cardinality="many",
+                optional=True,
+            )
+            children_data = data.get("children", None) if isinstance(data, dict) else None
+            self._hierarchical_data["children"] = RelationshipManager(
+                name="children",
+                client=self._client,
+                node=self,
+                branch=self._branch,
+                schema=children_schema,
+                data=children_data,
+            )
+            # Create pseudo-schema for ancestors (read-only, many cardinality)
+            ancestors_schema = RelationshipSchemaAPI(
+                name="ancestors",
+                peer=self._schema.hierarchy,  # type: ignore[union-attr, arg-type]
+                cardinality="many",
+                read_only=True,
+                optional=True,
+            )
+            ancestors_data = data.get("ancestors", None) if isinstance(data, dict) else None
+            self._hierarchical_data["ancestors"] = RelationshipManager(
+                name="ancestors",
+                client=self._client,
+                node=self,
+                branch=self._branch,
+                schema=ancestors_schema,
+                data=ancestors_data,
+            )
+            # Create pseudo-schema for descendants (read-only, many cardinality)
+            descendants_schema = RelationshipSchemaAPI(
+                name="descendants",
+                peer=self._schema.hierarchy,  # type: ignore[union-attr, arg-type]
+                cardinality="many",
+                read_only=True,
+                optional=True,
+            )
+            descendants_data = data.get("descendants", None) if isinstance(data, dict) else None
+            self._hierarchical_data["descendants"] = RelationshipManager(
+                name="descendants",
+                client=self._client,
+                node=self,
+                branch=self._branch,
+                schema=descendants_schema,
+                data=descendants_data,
+            )
 
     def __getattr__(self, name: str) -> Attribute | RelationshipManager | RelatedNode:
         if "_attribute_data" in self.__dict__ and name in self._attribute_data:
@@ -540,6 +632,8 @@ class InfrahubNode(InfrahubNodeBase):
             return self._relationship_cardinality_many_data[name]
         if "_relationship_cardinality_one_data" in self.__dict__ and name in self._relationship_cardinality_one_data:
             return self._relationship_cardinality_one_data[name]
+        if "_hierarchical_data" in self.__dict__ and name in self._hierarchical_data:
+            return self._hierarchical_data[name]
 
         raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
 
@@ -628,6 +722,57 @@ class InfrahubNode(InfrahubNodeBase):
 
         self._client.store.set(node=self)
 
+    async def _process_hierarchical_fields(
+        self,
+        data: dict[str, Any],
+        include: list[str] | None = None,
+        exclude: list[str] | None = None,
+        prefetch_relationships: bool = False,
+        insert_alias: bool = False,
+        property: bool = False,
+    ) -> None:
+        """Process hierarchical fields (parent, children, ancestors, descendants) for hierarchical nodes."""
+        if not self._hierarchy_support:
+            return
+
+        for hierarchical_name in ["parent", "children", "ancestors", "descendants"]:
+            if exclude and hierarchical_name in exclude:
+                continue
+
+            # Only include if explicitly requested or if prefetch_relationships is True
+            should_fetch = prefetch_relationships or (include is not None and hierarchical_name in include)
+            if not should_fetch:
+                continue
+
+            peer_schema = await self._client.schema.get(kind=self._schema.hierarchy, branch=self._branch)  # type: ignore[union-attr, arg-type]
+            peer_node = InfrahubNode(client=self._client, schema=peer_schema, branch=self._branch)
+            # Exclude hierarchical fields from peer data to prevent infinite recursion
+            peer_exclude = list(exclude) if exclude else []
+            peer_exclude.extend(["parent", "children", "ancestors", "descendants"])
+            peer_data = await peer_node.generate_query_data_node(
+                exclude=peer_exclude,
+                property=property,
+            )
+
+            # Parent is cardinality one, others are cardinality many
+            if hierarchical_name == "parent":
+                hierarchical_data = RelatedNode._generate_query_data(peer_data=peer_data, property=property)
+                # Use fragment for hierarchical fields similar to hierarchy relationships
+                data_node = hierarchical_data["node"]
+                hierarchical_data["node"] = {}
+                hierarchical_data["node"][f"...on {self._schema.hierarchy}"] = data_node  # type: ignore[union-attr]
+            else:
+                hierarchical_data = RelationshipManager._generate_query_data(peer_data=peer_data, property=property)
+                # Use fragment for hierarchical fields similar to hierarchy relationships
+                data_node = hierarchical_data["edges"]["node"]
+                hierarchical_data["edges"]["node"] = {}
+                hierarchical_data["edges"]["node"][f"...on {self._schema.hierarchy}"] = data_node  # type: ignore[union-attr]
+
+            data[hierarchical_name] = hierarchical_data
+
+            if insert_alias:
+                data[hierarchical_name]["@alias"] = f"__alias__{self._schema.kind}__{hierarchical_name}"
+
     async def generate_query_data(
         self,
         filters: dict[str, Any] | None = None,
@@ -755,6 +900,7 @@ class InfrahubNode(InfrahubNodeBase):
                     property=property,
                 )
 
+            rel_data: dict[str, Any]
             if rel_schema and rel_schema.cardinality == "one":
                 rel_data = RelatedNode._generate_query_data(peer_data=peer_data, property=property)
                 # Nodes involved in a hierarchy are required to inherit from a common ancestor node, and graphql
@@ -767,12 +913,24 @@ class InfrahubNode(InfrahubNodeBase):
                     rel_data["node"][f"...on {rel_schema.peer}"] = data_node
             elif rel_schema and rel_schema.cardinality == "many":
                 rel_data = RelationshipManager._generate_query_data(peer_data=peer_data, property=property)
+            else:
+                continue
 
             data[rel_name] = rel_data
 
             if insert_alias:
                 data[rel_name]["@alias"] = f"__alias__{self._schema.kind}__{rel_name}"
 
+        # Add parent, children, ancestors and descendants for hierarchical nodes
+        await self._process_hierarchical_fields(
+            data=data,
+            include=include,
+            exclude=exclude,
+            prefetch_relationships=prefetch_relationships,
+            insert_alias=insert_alias,
+            property=property,
+        )
+
         return data
 
     async def add_relationships(self, relation_to_update: str, related_nodes: list[str]) -> None:
@@ -1132,6 +1290,7 @@ class InfrahubNodeSync(InfrahubNodeBase):
 
         self._relationship_cardinality_many_data: dict[str, RelationshipManagerSync] = {}
         self._relationship_cardinality_one_data: dict[str, RelatedNodeSync] = {}
+        self._hierarchical_data: dict[str, RelatedNodeSync | RelationshipManagerSync] = {}
 
         super().__init__(schema=schema, branch=branch or client.default_branch, data=data)
 
@@ -1186,6 +1345,79 @@ class InfrahubNodeSync(InfrahubNodeBase):
                     data=rel_data,
                 )
 
+        # Initialize parent, children, ancestors and descendants for hierarchical nodes
+        if self._hierarchy_support:
+            # Create pseudo-schema for parent (cardinality one)
+            parent_schema = RelationshipSchemaAPI(
+                name="parent",
+                peer=self._schema.hierarchy,  # type: ignore[union-attr, arg-type]
+                kind=RelationshipKind.HIERARCHY,
+                cardinality="one",
+                optional=True,
+            )
+            parent_data = data.get("parent", None) if isinstance(data, dict) else None
+            self._hierarchical_data["parent"] = RelatedNodeSync(
+                name="parent",
+                client=self._client,
+                branch=self._branch,
+                schema=parent_schema,
+                data=parent_data,
+            )
+
+            # Create pseudo-schema for children (many cardinality)
+            children_schema = RelationshipSchemaAPI(
+                name="children",
+                peer=self._schema.hierarchy,  # type: ignore[union-attr, arg-type]
+                kind=RelationshipKind.HIERARCHY,
+                cardinality="many",
+                optional=True,
+            )
+            children_data = data.get("children", None) if isinstance(data, dict) else None
+            self._hierarchical_data["children"] = RelationshipManagerSync(
+                name="children",
+                client=self._client,
+                node=self,
+                branch=self._branch,
+                schema=children_schema,
+                data=children_data,
+            )
+
+            # Create pseudo-schema for ancestors (read-only, many cardinality)
+            ancestors_schema = RelationshipSchemaAPI(
+                name="ancestors",
+                peer=self._schema.hierarchy,  # type: ignore[union-attr, arg-type]
+                cardinality="many",
+                read_only=True,
+                optional=True,
+            )
+            ancestors_data = data.get("ancestors", None) if isinstance(data, dict) else None
+            self._hierarchical_data["ancestors"] = RelationshipManagerSync(
+                name="ancestors",
+                client=self._client,
+                node=self,
+                branch=self._branch,
+                schema=ancestors_schema,
+                data=ancestors_data,
+            )
+
+            # Create pseudo-schema for descendants (read-only, many cardinality)
+            descendants_schema = RelationshipSchemaAPI(
+                name="descendants",
+                peer=self._schema.hierarchy,  # type: ignore[union-attr, arg-type]
+                cardinality="many",
+                read_only=True,
+                optional=True,
+            )
+            descendants_data = data.get("descendants", None) if isinstance(data, dict) else None
+            self._hierarchical_data["descendants"] = RelationshipManagerSync(
+                name="descendants",
+                client=self._client,
+                node=self,
+                branch=self._branch,
+                schema=descendants_schema,
+                data=descendants_data,
+            )
+
     def __getattr__(self, name: str) -> Attribute | RelationshipManagerSync | RelatedNodeSync:
         if "_attribute_data" in self.__dict__ and name in self._attribute_data:
             return self._attribute_data[name]
@@ -1193,6 +1425,8 @@ class InfrahubNodeSync(InfrahubNodeBase):
             return self._relationship_cardinality_many_data[name]
         if "_relationship_cardinality_one_data" in self.__dict__ and name in self._relationship_cardinality_one_data:
             return self._relationship_cardinality_one_data[name]
+        if "_hierarchical_data" in self.__dict__ and name in self._hierarchical_data:
+            return self._hierarchical_data[name]
 
         raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
 
@@ -1274,6 +1508,57 @@ class InfrahubNodeSync(InfrahubNodeBase):
 
         self._client.store.set(node=self)
 
+    def _process_hierarchical_fields(
+        self,
+        data: dict[str, Any],
+        include: list[str] | None = None,
+        exclude: list[str] | None = None,
+        prefetch_relationships: bool = False,
+        insert_alias: bool = False,
+        property: bool = False,
+    ) -> None:
+        """Process hierarchical fields (parent, children, ancestors, descendants) for hierarchical nodes."""
+        if not self._hierarchy_support:
+            return
+
+        for hierarchical_name in ["parent", "children", "ancestors", "descendants"]:
+            if exclude and hierarchical_name in exclude:
+                continue
+
+            # Only include if explicitly requested or if prefetch_relationships is True
+            should_fetch = prefetch_relationships or (include is not None and hierarchical_name in include)
+            if not should_fetch:
+                continue
+
+            peer_schema = self._client.schema.get(kind=self._schema.hierarchy, branch=self._branch)  # type: ignore[union-attr, arg-type]
+            peer_node = InfrahubNodeSync(client=self._client, schema=peer_schema, branch=self._branch)
+            # Exclude hierarchical fields from peer data to prevent infinite recursion
+            peer_exclude = list(exclude) if exclude else []
+            peer_exclude.extend(["parent", "children", "ancestors", "descendants"])
+            peer_data = peer_node.generate_query_data_node(
+                exclude=peer_exclude,
+                property=property,
+            )
+
+            # Parent is cardinality one, others are cardinality many
+            if hierarchical_name == "parent":
+                hierarchical_data = RelatedNodeSync._generate_query_data(peer_data=peer_data, property=property)
+                # Use fragment for hierarchical fields similar to hierarchy relationships
+                data_node = hierarchical_data["node"]
+                hierarchical_data["node"] = {}
+                hierarchical_data["node"][f"...on {self._schema.hierarchy}"] = data_node  # type: ignore[union-attr]
+            else:
+                hierarchical_data = RelationshipManagerSync._generate_query_data(peer_data=peer_data, property=property)
+                # Use fragment for hierarchical fields similar to hierarchy relationships
+                data_node = hierarchical_data["edges"]["node"]
+                hierarchical_data["edges"]["node"] = {}
+                hierarchical_data["edges"]["node"][f"...on {self._schema.hierarchy}"] = data_node  # type: ignore[union-attr]
+
+            data[hierarchical_name] = hierarchical_data
+
+            if insert_alias:
+                data[hierarchical_name]["@alias"] = f"__alias__{self._schema.kind}__{hierarchical_name}"
+
     def generate_query_data(
         self,
         filters: dict[str, Any] | None = None,
@@ -1396,8 +1681,11 @@ class InfrahubNodeSync(InfrahubNodeBase):
             if rel_schema and should_fetch_relationship:
                 peer_schema = self._client.schema.get(kind=rel_schema.peer, branch=self._branch)
                 peer_node = InfrahubNodeSync(client=self._client, schema=peer_schema, branch=self._branch)
-                peer_data = peer_node.generate_query_data_node(include=include, exclude=exclude, property=property)
+                peer_data = peer_node.generate_query_data_node(
+                    property=property,
+                )
 
+            rel_data: dict[str, Any]
             if rel_schema and rel_schema.cardinality == "one":
                 rel_data = RelatedNodeSync._generate_query_data(peer_data=peer_data, property=property)
                 # Nodes involved in a hierarchy are required to inherit from a common ancestor node, and graphql
@@ -1410,12 +1698,24 @@ class InfrahubNodeSync(InfrahubNodeBase):
                     rel_data["node"][f"...on {rel_schema.peer}"] = data_node
             elif rel_schema and rel_schema.cardinality == "many":
                 rel_data = RelationshipManagerSync._generate_query_data(peer_data=peer_data, property=property)
+            else:
+                continue
 
             data[rel_name] = rel_data
 
             if insert_alias:
                 data[rel_name]["@alias"] = f"__alias__{self._schema.kind}__{rel_name}"
 
+        # Add parent, children, ancestors and descendants for hierarchical nodes
+        self._process_hierarchical_fields(
+            data=data,
+            include=include,
+            exclude=exclude,
+            prefetch_relationships=prefetch_relationships,
+            insert_alias=insert_alias,
+            property=property,
+        )
+
         return data
 
     def add_relationships(

infrahub_sdk/node/related_node.py

@@ -64,7 +64,7 @@ class RelatedNodeBase:
                 self._display_label = node_data.get("display_label", None)
                 self._typename = node_data.get("__typename", None)
 
-            self.updated_at: str | None = data.get("updated_at", data.get("_relation__updated_at"))
+            self.updated_at: str | None = data.get("updated_at", properties_data.get("updated_at", None))
 
             # FIXME, we won't need that once we are only supporting paginated results
             if self._typename and self._typename.startswith("Related"):
@@ -171,7 +171,6 @@ class RelatedNodeBase:
             for prop_name in PROPERTIES_OBJECT:
                 properties[prop_name] = {"id": None, "display_label": None, "__typename": None}
 
-        if properties:
             data["properties"] = properties
         if peer_data:
             data["node"].update(peer_data)

infrahub_sdk/node/relationship.py

@@ -87,9 +87,8 @@ class RelationshipManagerBase:
                 properties[prop_name] = None
             for prop_name in PROPERTIES_OBJECT:
                 properties[prop_name] = {"id": None, "display_label": None, "__typename": None}
-
-        if properties:
             data["edges"]["properties"] = properties
+
         if peer_data:
             data["edges"]["node"].update(peer_data)
 

infrahub_sdk/protocols_base.py

@@ -56,7 +56,6 @@ class Attribute(Protocol):
     is_from_profile: bool | None
     is_inherited: bool | None
     updated_at: str | None
-    is_visible: bool | None
     is_protected: bool | None
 
 

infrahub_sdk/pytest_plugin/AGENTS.md

@@ -0,0 +1,67 @@
+# infrahub_sdk/pytest_plugin/AGENTS.md
+
+Custom pytest plugin for testing Infrahub resources via YAML test files.
+
+## YAML Test Format
+
+```yaml
+infrahub_tests:
+  - resource: Check  # Check, GraphQLQuery, Jinja2Transform, PythonTransform
+    resource_name: my_check
+    tests:
+      - name: test_success_case
+        spec:
+          kind: check-smoke  # See test kinds below
+        input:
+          data: {...}
+        output:
+          passed: true
+```
+
+## Test Kinds
+
+| Resource | Smoke | Unit | Integration |
+| -------- | ----- | ---- | ----------- |
+| Check | `check-smoke` | `check-unit-process` | `check-integration` |
+| GraphQL | `graphql-query-smoke` | - | `graphql-query-integration` |
+| Jinja2 | `jinja2-transform-smoke` | `jinja2-transform-unit-render` | `jinja2-transform-integration` |
+| Python | `python-transform-smoke` | `python-transform-unit-process` | `python-transform-integration` |
+
+## Plugin Structure
+
+```text
+infrahub_sdk/pytest_plugin/
+├── plugin.py      # Pytest hooks (pytest_collect_file, etc.)
+├── loader.py      # YAML loading, ITEMS_MAPPING
+├── models.py      # Pydantic schemas for test files
+└── items/         # Test item implementations
+    ├── base.py    # InfrahubItem base class
+    └── check.py   # Check-specific items
+```
+
+## Adding New Test Item
+
+```python
+# 1. Create item class in items/
+class MyCustomItem(InfrahubItem):
+    def runtest(self):
+        result = self.process(self.test.input)
+        assert result == self.test.output
+
+# 2. Register in loader.py
+ITEMS_MAPPING = {
+    "my-custom-test": MyCustomItem,
+    ...
+}
+```
+
+## Boundaries
+
+✅ **Always**
+
+- Register new items in `ITEMS_MAPPING`
+- Inherit from `InfrahubItem` base class
+
+🚫 **Never**
+
+- Forget to add new test kinds to `ITEMS_MAPPING`

infrahub_sdk/schema/__init__.py

@@ -154,7 +154,6 @@ class InfrahubSchemaBase:
         source: str | None = None,
         owner: str | None = None,
         is_protected: bool | None = None,
-        is_visible: bool | None = None,
     ) -> dict[str, Any]:
         obj_data: dict[str, Any] = {}
         item_metadata: dict[str, Any] = {}
@@ -164,8 +163,6 @@ class InfrahubSchemaBase:
             item_metadata["owner"] = str(owner)
         if is_protected is not None:
             item_metadata["is_protected"] = is_protected
-        if is_visible is not None:
-            item_metadata["is_visible"] = is_visible
 
         for key, value in data.items():
             obj_data[key] = {}

infrahub_sdk/timestamp.py

@@ -6,7 +6,7 @@ from datetime import datetime, timezone
 from typing import Literal, TypedDict
 
 from typing_extensions import NotRequired
-from whenever import Date, Instant, LocalDateTime, OffsetDateTime, Time, ZonedDateTime
+from whenever import Date, Instant, OffsetDateTime, PlainDateTime, Time, ZonedDateTime
 
 from .exceptions import TimestampFormatError
 
@@ -51,30 +51,30 @@ class Timestamp:
     @classmethod
     def _parse_string(cls, value: str) -> ZonedDateTime:
         try:
-            return ZonedDateTime.parse_common_iso(value)
+            return ZonedDateTime.parse_iso(value)
         except ValueError:
             pass
 
         try:
-            instant_date = Instant.parse_common_iso(value)
+            instant_date = Instant.parse_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")
+            plain_date_time = PlainDateTime.parse_iso(value)
+            return plain_date_time.assume_utc().to_tz("UTC")
         except ValueError:
             pass
 
         try:
-            offset_date_time = OffsetDateTime.parse_common_iso(value)
+            offset_date_time = OffsetDateTime.parse_iso(value)
             return offset_date_time.to_tz("UTC")
         except ValueError:
             pass
 
         try:
-            date = Date.parse_common_iso(value)
+            date = Date.parse_iso(value)
             local_date = date.at(Time(12, 00))
             return local_date.assume_tz("UTC", disambiguate="compatible")
         except ValueError:

{infrahub_server-1.6.0b0.dist-info → infrahub_server-1.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: infrahub-server
-Version: 1.6.0b0
+Version: 1.6.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.
 Project-URL: Homepage, https://opsmill.com
 Project-URL: Repository, https://github.com/opsmill/infrahub
@@ -21,7 +21,6 @@ Requires-Dist: bcrypt<4.2,>=4.1
 Requires-Dist: boto3==1.34.129
 Requires-Dist: cachetools-async==0.0.5
 Requires-Dist: click==8.1.7
-Requires-Dist: copier==9.8.0
 Requires-Dist: deepdiff==8.6.1
 Requires-Dist: dulwich==0.22.7
 Requires-Dist: email-validator<2.2,>=2.1
@@ -60,7 +59,7 @@ Requires-Dist: tomli>=1.1.0; python_version <= '3.11'
 Requires-Dist: typer==0.19.2
 Requires-Dist: ujson<6,>=5
 Requires-Dist: uvicorn[standard]<0.33,>=0.32
-Requires-Dist: whenever==0.7.3
+Requires-Dist: whenever==0.9.3
 Description-Content-Type: text/markdown
 
 <h1 align="center">