updates

Author: ogenstad

changelog/+040fc56b.housekeeping.md

@@ -0,0 +1 @@
+Refactor InfrahubNode to avoid the creation of a dynamic Python class for each object defined

infrahub_sdk/ctl/generator.py

@@ -74,20 +74,20 @@ async def run(
         targets = await client.get(
             kind="CoreGroup", branch=branch, include=["members"], name__value=generator_config.targets
         )
-        await targets.members.fetch()
+        await targets._get_relationship_many(name="members").fetch()
 
-        if not targets.members.peers:
+        if not targets._get_relationship_many(name="members").peers:
             console.print(
                 f"[red]No members found within '{generator_config.targets}', not running generator '{generator_name}'"
             )
             return
 
-        for member in targets.members.peers:
+        for member in targets._get_relationship_many(name="members").peers:
             check_parameter = {}
             if identifier:
                 attribute = getattr(member.peer, identifier)
                 check_parameter = {identifier: attribute.value}
-            params = {"name": member.peer.name.value}
+            params = {"name": member.peer._get_attribute(name="name").value}
             generator = generator_class(
                 query=generator_config.query,
                 client=client,

infrahub_sdk/node/node.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
+from collections.abc import Iterable
 from copy import copy
 from typing import TYPE_CHECKING, Any
 
 from ..constants import InfrahubClientMode
-from ..exceptions import FeatureNotSupportedError, NodeNotFoundError, SchemaNotFoundError
+from ..exceptions import FeatureNotSupportedError, NodeNotFoundError, ResourceNotDefinedError, SchemaNotFoundError
 from ..graphql import Mutation, Query
 from ..schema import GenericSchemaAPI, RelationshipCardinality, RelationshipKind
 from ..utils import compare_lists, generate_short_id, get_flat_value
@@ -42,8 +43,6 @@ def __init__(self, schema: MainSchemaTypesAPI, branch: str, data: dict | None =
         self._branch = branch
         self._existing: bool = True
         self._attribute_data: dict[str, Attribute] = {}
-        self._relationship_cardinality_many_data: dict[str, RelationshipManager | RelationshipManagerSync] = {}
-        self._relationship_cardinality_one_data: dict[str, RelatedNode | RelatedNodeSync] = {}
 
         # Generate a unique ID only to be used inside the SDK
         # The format if this ID is purposely different from the ID used by the API
@@ -142,18 +141,6 @@ def _init_attributes(self, data: dict | None = None) -> None:
                 name=attr_schema.name, schema=attr_schema, data=attr_data
             )
 
-    def __getattr__(
-        self, name: str
-    ) -> Attribute | RelationshipManager | RelationshipManagerSync | RelatedNode | RelatedNodeSync:
-        if "_attribute_data" in self.__dict__ and name in self._attribute_data:
-            return self._attribute_data[name]
-        if "_relationship_cardinality_many_data" in self.__dict__ and name in self._relationship_cardinality_many_data:
-            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]
-
-        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
-
     def __setattr__(self, name: str, value: Any) -> None:
         """Set values for attributes that exist or revert to normal behaviour"""
         if "_attribute_data" in self.__dict__ and name in self._attribute_data:
@@ -463,6 +450,12 @@ def _relationship_mutation(self, action: str, relation_to_update: str, related_n
         }}
         """
 
+    def _get_attribute(self, name: str) -> Attribute:
+        if name in self._attribute_data:
+            return self._attribute_data[name]
+
+        raise ResourceNotDefinedError(message=f"The node doesn't have an attribute for {name}")
+
 
 class InfrahubNode(InfrahubNodeBase):
     """Represents a Infrahub node in an asynchronous context."""
@@ -486,6 +479,9 @@ def __init__(
         if isinstance(data, dict) and isinstance(data.get("node"), dict):
             data = data.get("node")
 
+        self._relationship_cardinality_many_data: dict[str, RelationshipManager] = {}
+        self._relationship_cardinality_one_data: dict[str, RelatedNode] = {}
+
         super().__init__(schema=schema, branch=branch or client.default_branch, data=data)
 
     @classmethod
@@ -523,6 +519,16 @@ def _init_relationships(self, data: dict | None = None) -> None:
                     data=rel_data,
                 )
 
+    def __getattr__(self, name: str) -> Attribute | RelationshipManager | RelatedNode:
+        if "_attribute_data" in self.__dict__ and name in self._attribute_data:
+            return self._attribute_data[name]
+        if "_relationship_cardinality_many_data" in self.__dict__ and name in self._relationship_cardinality_many_data:
+            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]
+
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
     def __setattr__(self, name: str, value: Any) -> None:
         """Set values for relationship names that exist or revert to normal behaviour"""
         if "_relationship_cardinality_one_data" in self.__dict__ and name in self._relationship_cardinality_one_data:
@@ -552,14 +558,14 @@ async def artifact_generate(self, name: str) -> None:
         self._validate_artifact_support(ARTIFACT_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE)
 
         artifact = await self._client.get(kind="CoreArtifact", name__value=name, object__ids=[self.id])
-        await artifact.definition.fetch()  # type: ignore[attr-defined]
-        await artifact.definition.peer.generate([artifact.id])  # type: ignore[attr-defined]
+        await artifact._get_relationship_one(name="definition").fetch()
+        await artifact._get_relationship_one(name="definition").peer.generate([artifact.id])
 
     async def artifact_fetch(self, name: str) -> str | dict[str, Any]:
         self._validate_artifact_support(ARTIFACT_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE)
 
         artifact = await self._client.get(kind="CoreArtifact", name__value=name, object__ids=[self.id])
-        content = await self._client.object_store.get(identifier=artifact.storage_id.value)  # type: ignore[attr-defined]
+        content = await self._client.object_store.get(identifier=artifact._get_attribute(name="storage_id").value)
         return content
 
     async def delete(self, timeout: int | None = None, request_context: RequestContext | None = None) -> None:
@@ -1002,6 +1008,27 @@ async def get_pool_resources_utilization(self) -> list[dict[str, Any]]:
             return [edge["node"] for edge in response[graphql_query_name]["edges"]]
         return []
 
+    def _get_relationship_many(self, name: str) -> RelationshipManager:
+        if name in self._relationship_cardinality_many_data:
+            return self._relationship_cardinality_many_data[name]
+
+        raise ResourceNotDefinedError(message=f"The node doesn't have a cardinality=many relationship for {name}")
+
+    def _get_relationship_one(self, name: str) -> RelatedNode:
+        if name in self._relationship_cardinality_one_data:
+            return self._relationship_cardinality_one_data[name]
+
+        raise ResourceNotDefinedError(message=f"The node doesn't have a cardinality=one relationship for {name}")
+
+    def __dir__(self) -> Iterable[str]:
+        base = list(super().__dir__())
+        return sorted(
+            base
+            + list(self._attribute_data.keys())
+            + list(self._relationship_cardinality_many_data.keys())
+            + list(self._relationship_cardinality_one_data.keys())
+        )
+
 
 class InfrahubNodeSync(InfrahubNodeBase):
     """Represents a Infrahub node in a synchronous context."""
@@ -1025,6 +1052,9 @@ def __init__(
         if isinstance(data, dict) and isinstance(data.get("node"), dict):
             data = data.get("node")
 
+        self._relationship_cardinality_many_data: dict[str, RelationshipManagerSync] = {}
+        self._relationship_cardinality_one_data: dict[str, RelatedNodeSync] = {}
+
         super().__init__(schema=schema, branch=branch or client.default_branch, data=data)
 
     @classmethod
@@ -1063,6 +1093,16 @@ def _init_relationships(self, data: dict | None = None) -> None:
                     data=rel_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]
+        if "_relationship_cardinality_many_data" in self.__dict__ and name in self._relationship_cardinality_many_data:
+            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]
+
+        raise AttributeError(f"'{self.__class__.__name__}' object has no attribute '{name}'")
+
     def __setattr__(self, name: str, value: Any) -> None:
         """Set values for relationship names that exist or revert to normal behaviour"""
         if "_relationship_cardinality_one_data" in self.__dict__ and name in self._relationship_cardinality_one_data:
@@ -1090,13 +1130,13 @@ def generate(self, nodes: list[str] | None = None) -> None:
     def artifact_generate(self, name: str) -> None:
         self._validate_artifact_support(ARTIFACT_GENERATE_FEATURE_NOT_SUPPORTED_MESSAGE)
         artifact = self._client.get(kind="CoreArtifact", name__value=name, object__ids=[self.id])
-        artifact.definition.fetch()  # type: ignore[attr-defined]
-        artifact.definition.peer.generate([artifact.id])  # type: ignore[attr-defined]
+        artifact._get_relationship_one(name="definition").fetch()
+        artifact._get_relationship_one(name="definition").peer.generate([artifact.id])
 
     def artifact_fetch(self, name: str) -> str | dict[str, Any]:
         self._validate_artifact_support(ARTIFACT_FETCH_FEATURE_NOT_SUPPORTED_MESSAGE)
         artifact = self._client.get(kind="CoreArtifact", name__value=name, object__ids=[self.id])
-        content = self._client.object_store.get(identifier=artifact.storage_id.value)  # type: ignore[attr-defined]
+        content = self._client.object_store.get(identifier=artifact._get_attribute(name="storage_id").value)
         return content
 
     def delete(self, timeout: int | None = None, request_context: RequestContext | None = None) -> None:
@@ -1538,3 +1578,24 @@ def get_pool_resources_utilization(self) -> list[dict[str, Any]]:
         if response[graphql_query_name].get("count", 0):
             return [edge["node"] for edge in response[graphql_query_name]["edges"]]
         return []
+
+    def _get_relationship_many(self, name: str) -> RelationshipManager | RelationshipManagerSync:
+        if name in self._relationship_cardinality_many_data:
+            return self._relationship_cardinality_many_data[name]
+
+        raise ResourceNotDefinedError(message=f"The node doesn't have a cardinality=many relationship for {name}")
+
+    def _get_relationship_one(self, name: str) -> RelatedNode | RelatedNodeSync:
+        if name in self._relationship_cardinality_one_data:
+            return self._relationship_cardinality_one_data[name]
+
+        raise ResourceNotDefinedError(message=f"The node doesn't have a cardinality=one relationship for {name}")
+
+    def __dir__(self) -> Iterable[str]:
+        base = list(super().__dir__())
+        return sorted(
+            base
+            + list(self._attribute_data.keys())
+            + list(self._relationship_cardinality_many_data.keys())
+            + list(self._relationship_cardinality_one_data.keys())
+        )

infrahub_sdk/query_groups.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Sequence
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any
 
 from .constants import InfrahubClientMode
 from .exceptions import NodeNotFoundError
@@ -101,7 +102,7 @@ async def get_group(self, store_peers: bool = False) -> InfrahubNode | None:
         if not store_peers:
             return group
 
-        self.previous_members = group._relationship_cardinality_many_data["members"].peers
+        self.previous_members = group._get_relationship_many(name="members").peers
         return group
 
     async def delete_unused(self) -> None:
@@ -195,7 +196,7 @@ def get_group(self, store_peers: bool = False) -> InfrahubNodeSync | None:
         if not store_peers:
             return group
 
-        self.previous_members = group._relationship_cardinality_many_data["members"].peers
+        self.previous_members = group._get_relationship_many(name="members").peers
         return group
 
     def delete_unused(self) -> None:

pyproject.toml

@@ -113,10 +113,6 @@ disallow_untyped_defs = true
 module = "infrahub_sdk.ctl.check"
 disable_error_code = ["call-overload"]
 
-[[tool.mypy.overrides]]
-module = "infrahub_sdk.ctl.generator"
-disable_error_code = ["attr-defined"]
-
 [[tool.mypy.overrides]]
 module = "infrahub_sdk.ctl.schema"
 disable_error_code = ["arg-type", "attr-defined", "misc", "union-attr"]

tests/unit/sdk/test_node.py

@@ -187,6 +187,12 @@ async def test_init_node_data_user_with_relationships(client, location_schema: N
     assert isinstance(node.primary_tag, RelatedNodeBase)
     assert node.primary_tag.id == "pppppppp"
 
+    keys = dir(node)
+    assert "name" in keys
+    assert "type" in keys
+    assert "tags" in keys
+    assert "get_kind" in keys
+
 
 @pytest.mark.parametrize("property_test", property_tests)
 @pytest.mark.parametrize("client_type", client_types)