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

infrahub/config.py

@@ -327,7 +327,7 @@ class DevelopmentSettings(BaseSettings):
         description="Allow enterprise configuration in development mode, this will not enable the features just allow the configuration.",
     )
     git_credential_helper: str = Field(
-        default="infrahub-git-credential",
+        default="/usr/local/bin/infrahub-git-credential",
         description="Location of git credential helper",
     )
 

infrahub/core/constants/__init__.py

@@ -391,4 +391,3 @@ DEFAULT_REL_IDENTIFIER_LENGTH = 128
 OBJECT_TEMPLATE_RELATIONSHIP_NAME = "object_template"
 OBJECT_TEMPLATE_NAME_ATTR = "template_name"
 PROFILE_NODE_RELATIONSHIP_IDENTIFIER = "node__profile"
-PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER = "template__profile"

infrahub/core/manager.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Any, Iterable, Literal, TypeVar, overload
 
 from infrahub_sdk.utils import deep_merge_dict, is_valid_uuid
 
-from infrahub.core.constants import InfrahubKind, RelationshipCardinality, RelationshipDirection
+from infrahub.core.constants import RelationshipCardinality, RelationshipDirection
 from infrahub.core.node import Node
 from infrahub.core.node.delete_validator import NodeDeleteValidator
 from infrahub.core.query.node import (
@@ -188,22 +188,17 @@ class NodeManager:
         await query.execute(db=db)
         node_ids = query.get_node_ids()
 
-        if (
-            fields
-            and "identifier" in fields
-            and node_schema.kind
-            in [
-                InfrahubKind.BASEPERMISSION,
-                InfrahubKind.GLOBALPERMISSION,
-                InfrahubKind.OBJECTPERMISSION,
-            ]
-        ):
-            # This is a workaround to ensure we are querying the right fields for permissions
-            # The identifier for permissions needs the same fields as the display label
+        # if display_label or hfid has been requested we need to ensure we are querying the right fields
+        if fields and "display_label" in fields:
             schema_branch = db.schema.get_schema_branch(name=branch.name)
             display_label_fields = schema_branch.generate_fields_for_display_label(name=node_schema.kind)
             if display_label_fields:
-                deep_merge_dict(dicta=fields, dictb=display_label_fields)
+                fields = deep_merge_dict(dicta=fields, dictb=display_label_fields)
+
+        if fields and "hfid" in fields and node_schema.human_friendly_id:
+            hfid_fields = node_schema.generate_fields_for_hfid()
+            if hfid_fields:
+                fields = deep_merge_dict(dicta=fields, dictb=hfid_fields)
 
         response = await cls.get_many(
             ids=node_ids,
@@ -305,8 +300,6 @@ class NodeManager:
         branch: Branch | str | None = None,
         branch_agnostic: bool = False,
         fetch_peers: bool = False,
-        include_source: bool = False,
-        include_owner: bool = False,
     ) -> list[Relationship]:
         branch = await registry.get_branch(branch=branch, db=db)
         at = Timestamp(at)
@@ -331,31 +324,24 @@ class NodeManager:
         if not peers_info:
             return []
 
-        if fields and "identifier" in fields:
-            # This is a workaround to ensure we are querying the right fields for permissions
-            # The identifier for permissions needs the same fields as the display label
+        # if display_label has been requested we need to ensure we are querying the right fields
+        if fields and "display_label" in fields:
+            peer_schema = schema.get_peer_schema(db=db, branch=branch)
+            schema_branch = db.schema.get_schema_branch(name=branch.name)
+            display_label_fields = schema_branch.generate_fields_for_display_label(name=peer_schema.kind)
+            if display_label_fields:
+                fields = deep_merge_dict(dicta=fields, dictb=display_label_fields)
+
+        if fields and "hfid" in fields:
             peer_schema = schema.get_peer_schema(db=db, branch=branch)
-            if peer_schema.kind in [
-                InfrahubKind.BASEPERMISSION,
-                InfrahubKind.GLOBALPERMISSION,
-                InfrahubKind.OBJECTPERMISSION,
-            ]:
-                schema_branch = db.schema.get_schema_branch(name=branch.name)
-                display_label_fields = schema_branch.generate_fields_for_display_label(name=peer_schema.kind)
-                if display_label_fields:
-                    deep_merge_dict(dicta=fields, dictb=display_label_fields)
+            hfid_fields = peer_schema.generate_fields_for_hfid()
+            if hfid_fields:
+                fields = deep_merge_dict(dicta=fields, dictb=hfid_fields)
 
         if fetch_peers:
             peer_ids = [peer.peer_id for peer in peers_info]
             peer_nodes = await cls.get_many(
-                db=db,
-                ids=peer_ids,
-                fields=fields,
-                at=at,
-                branch=branch,
-                branch_agnostic=branch_agnostic,
-                include_source=include_source,
-                include_owner=include_owner,
+                db=db, ids=peer_ids, fields=fields, at=at, branch=branch, branch_agnostic=branch_agnostic
             )
 
         results = []
@@ -434,6 +420,15 @@ class NodeManager:
         if not peers_ids:
             return {}
 
+        hierarchy_schema = node_schema.get_hierarchy_schema(db=db, branch=branch)
+
+        # if display_label has been requested we need to ensure we are querying the right fields
+        if fields and "display_label" in fields:
+            schema_branch = db.schema.get_schema_branch(name=branch.name)
+            display_label_fields = schema_branch.generate_fields_for_display_label(name=hierarchy_schema.kind)
+            if display_label_fields:
+                fields = deep_merge_dict(dicta=fields, dictb=display_label_fields)
+
         return await cls.get_many(
             db=db, ids=peers_ids, fields=fields, at=at, branch=branch, include_owner=True, include_source=True
         )

infrahub/core/models.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import contextlib
 import hashlib
 from typing import TYPE_CHECKING, Any
 
@@ -360,7 +359,7 @@ class SchemaUpdateValidationResult(BaseModel):
 
     def validate_migrations(self, migration_map: dict[str, Any]) -> None:
         for migration in self.migrations:
-            if migration_map.get(migration.migration_name) is None:
+            if migration_map.get(migration.migration_name, None) is None:
                 self.errors.append(
                     SchemaUpdateValidationError(
                         path=migration.path,
@@ -371,7 +370,7 @@ class SchemaUpdateValidationResult(BaseModel):
 
     def validate_constraints(self, validator_map: dict[str, Any]) -> None:
         for constraint in self.constraints:
-            if validator_map.get(constraint.constraint_name) is None:
+            if validator_map.get(constraint.constraint_name, None) is None:
                 self.errors.append(
                     SchemaUpdateValidationError(
                         path=constraint.path,
@@ -579,9 +578,11 @@ class HashableModel(BaseModel):
 
         for field_name in other.model_fields.keys():
             if not hasattr(self, field_name):
-                with contextlib.suppress(ValueError):
-                    # handles the case where self and other are different types and other has fields that self does not
+                try:
                     setattr(self, field_name, getattr(other, field_name))
+                except ValueError:
+                    # handles the case where self and other are different types and other has fields that self does not
+                    pass
                 continue
 
             attr_other = getattr(other, field_name)

infrahub/core/node/__init__.py

@@ -467,21 +467,15 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
         for attribute_name in template._attributes:
             if attribute_name in list(fields) + [OBJECT_TEMPLATE_NAME_ATTR]:
                 continue
-            attr = getattr(template, attribute_name)
-            attr_value = attr.value
+            attr_value = getattr(template, attribute_name).value
             if attr_value is not None:
-                # Preserve is_from_profile flag when copying from template
-                field_data = {"value": attr_value, "source": attr.source_id or template.id}
-                if attr.is_from_profile:
-                    field_data["is_from_profile"] = True
-                fields[attribute_name] = field_data
+                fields[attribute_name] = {"value": attr_value, "source": template.id}
 
         for relationship_name in template._relationships:
             relationship_schema = template._schema.get_relationship(name=relationship_name)
             if (
                 relationship_name in list(fields)
-                or relationship_schema.kind
-                not in [RelationshipKind.ATTRIBUTE, RelationshipKind.GENERIC, RelationshipKind.PROFILE]
+                or relationship_schema.kind not in [RelationshipKind.ATTRIBUTE, RelationshipKind.GENERIC]
                 or relationship_name == OBJECT_TEMPLATE_RELATIONSHIP_NAME
             ):
                 continue
@@ -576,7 +570,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     self,
                     rel_schema.name,
                     await generator_method(
-                        db=db, name=rel_schema.name, schema=rel_schema, data=fields.get(rel_schema.name)
+                        db=db, name=rel_schema.name, schema=rel_schema, data=fields.get(rel_schema.name, None)
                     ),
                 )
             except ValidationError as exc:
@@ -606,7 +600,7 @@ class Node(BaseNode, metaclass=BaseNodeMeta):
                     self,
                     attr_schema.name,
                     await generator_method(
-                        db=db, name=attr_schema.name, schema=attr_schema, data=fields.get(attr_schema.name)
+                        db=db, name=attr_schema.name, schema=attr_schema, data=fields.get(attr_schema.name, None)
                     ),
                 )
                 if not self._existing:

infrahub/core/node/create.py

@@ -58,34 +58,18 @@ async def extract_peer_data(
             except ValueError:
                 pass
 
-        # If the template attribute comes from a profile, preserve the profile as the source
-        # Otherwise, use the template itself as the source
-        source_id = template_attr.source_id or template_peer.id
-        attr_data = {"value": template_attr.value, "source": source_id}
-        if template_attr.is_from_profile:
-            attr_data["is_from_profile"] = True
-        obj_peer_data[attr_name] = attr_data
+        obj_peer_data[attr_name] = {"value": template_attr.value, "source": template_peer.id}
 
     for rel in template_peer.get_schema().relationship_names:
         rel_manager: RelationshipManager = getattr(template_peer, rel)
-        if (
-            rel_manager.schema.kind
-            not in [
-                RelationshipKind.COMPONENT,
-                RelationshipKind.PARENT,
-                RelationshipKind.PROFILE,
-                RelationshipKind.ATTRIBUTE,
-            ]
-            or rel_manager.schema.name not in obj_peer_schema.relationship_names
-        ):
+
+        if rel_manager.schema.name not in obj_peer_schema.relationship_names:
             continue
 
         peers_map = await rel_manager.get_peers(db=db)
-        if rel_manager.schema.kind in [
-            RelationshipKind.COMPONENT,
-            RelationshipKind.PARENT,
-            RelationshipKind.PROFILE,
-        ] and list(peers_map.keys()) == [current_template.id]:
+        if rel_manager.schema.kind in [RelationshipKind.COMPONENT, RelationshipKind.PARENT] and list(
+            peers_map.keys()
+        ) == [current_template.id]:
             obj_peer_data[rel] = {"id": parent_obj.id}
             continue
 
@@ -96,13 +80,7 @@ async def extract_peer_data(
                 continue
             rel_peer_ids.append({"id": peer_id})
 
-        # Only set the relationship data if there are actual peers to set
-        if rel_peer_ids:
-            obj_peer_data[rel] = rel_peer_ids
-
-        if rel_manager.schema.kind == RelationshipKind.PROFILE:
-            profiles = list(await rel_manager.get_peers(db=db))
-            obj_peer_data[rel] = profiles
+        obj_peer_data[rel] = rel_peer_ids
 
     return obj_peer_data
 
@@ -147,12 +125,6 @@ async def handle_template_relationships(
             await constraint_runner.check(node=obj_peer, field_filters=list(obj_peer_data))
             await obj_peer.save(db=db)
 
-            template_profile_ids = await get_profile_ids(db=db, obj=template_relationship_peer)
-            if template_profile_ids:
-                node_profiles_applier = NodeProfilesApplier(db=db, branch=branch)
-                await node_profiles_applier.apply_profiles(node=obj_peer)
-                await obj_peer.save(db=db)
-
             await handle_template_relationships(
                 db=db,
                 branch=branch,
@@ -164,7 +136,7 @@ async def handle_template_relationships(
             )
 
 
-async def get_profile_ids(db: InfrahubDatabase, obj: Node | CoreObjectTemplate) -> set[str]:
+async def get_profile_ids(db: InfrahubDatabase, obj: Node) -> set[str]:
     if not hasattr(obj, "profiles"):
         return set()
     profile_rels = await obj.profiles.get_relationships(db=db)

infrahub/core/node/standard.py

@@ -72,7 +72,7 @@ class StandardNode(BaseModel):
         response: dict[str, Any] = {"id": self.uuid}
 
         for field_name in fields.keys():
-            if field_name == "id":
+            if field_name in ["id"]:
                 continue
             if field_name == "__typename":
                 response[field_name] = self.get_type()

infrahub/core/protocols.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Optional, Protocol, runtime_checkable
 
 from infrahub.core.protocols_base import CoreNode
 
@@ -16,16 +16,22 @@ if TYPE_CHECKING:
         DateTime,
         DateTimeOptional,
         Dropdown,
+        DropdownOptional,
         HashedPassword,
+        HashedPasswordOptional,
         Integer,
         IntegerOptional,
         IPHost,
+        IPHostOptional,
         IPNetwork,
+        IPNetworkOptional,
         JSONAttribute,
         JSONAttributeOptional,
+        ListAttribute,
         ListAttributeOptional,
         String,
         StringOptional,
+        URLOptional,
     )
     from infrahub.core.relationship import RelationshipManager
 

infrahub/core/query/attribute.py

@@ -373,7 +373,7 @@ async def default_attribute_query_filter(
         if property_name not in [v.value for v in NodeProperty]:
             raise ValueError(f"filter {filter_name}: {filter_value}, {property_name} is not a valid property")
 
-        if property_attr != "id":
+        if property_attr not in ["id"]:
             raise ValueError(f"filter {filter_name}: {filter_value}, {property_attr} is supported")
 
         clean_filter_name = f"{property_name}_{property_attr}"

infrahub/core/query/node.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import contextlib
 from collections import defaultdict
 from copy import copy
 from dataclasses import dataclass
@@ -13,7 +12,6 @@ from infrahub.core import registry
 from infrahub.core.constants import (
     GLOBAL_BRANCH_NAME,
     PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
-    PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER,
     AttributeDBNodeType,
     RelationshipDirection,
     RelationshipHierarchyDirection,
@@ -625,8 +623,7 @@ class NodeListGetAttributeQuery(Query):
 
     async def query_init(self, db: InfrahubDatabase, **kwargs) -> None:  # noqa: ARG002
         self.params["ids"] = self.ids
-        self.params["profile_node_relationship_name"] = PROFILE_NODE_RELATIONSHIP_IDENTIFIER
-        self.params["profile_template_relationship_name"] = PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER
+        self.params["profile_relationship_name"] = PROFILE_NODE_RELATIONSHIP_IDENTIFIER
 
         branch_filter, branch_params = self.branch.get_query_filter_path(
             at=self.at, branch_agnostic=self.branch_agnostic
@@ -635,10 +632,7 @@ class NodeListGetAttributeQuery(Query):
 
         query = """
         MATCH (n:Node) WHERE n.uuid IN $ids
-        WITH n, (
-            exists((n)-[:IS_RELATED]-(:Relationship {name: $profile_node_relationship_name})) OR
-            exists((n)-[:IS_RELATED]-(:Relationship {name: $profile_template_relationship_name}))
-        ) AS might_use_profile
+        WITH n, exists((n)-[:IS_RELATED]-(:Relationship {name: $profile_relationship_name})) AS might_use_profile
         MATCH (n)-[:HAS_ATTRIBUTE]-(a:Attribute)
         """
         if self.fields:
@@ -1140,8 +1134,10 @@ class NodeGetListQuery(Query):
             self._variables_to_track.append(variable)
 
     def _untrack_variable(self, variable: str) -> None:
-        with contextlib.suppress(ValueError):
+        try:
             self._variables_to_track.remove(variable)
+        except ValueError:
+            ...
 
     def _get_tracked_variables(self) -> list[str]:
         return self._variables_to_track

infrahub/core/relationship/model.py

@@ -912,8 +912,6 @@ class RelationshipManager:
         db: InfrahubDatabase,
         peer_type: type[PeerType],
         branch_agnostic: bool = ...,
-        include_source: bool = ...,
-        include_owner: bool = ...,
     ) -> Mapping[str, PeerType]: ...
 
     @overload
@@ -922,8 +920,6 @@ class RelationshipManager:
         db: InfrahubDatabase,
         peer_type: None = None,
         branch_agnostic: bool = ...,
-        include_source: bool = ...,
-        include_owner: bool = ...,
     ) -> Mapping[str, Node]: ...
 
     async def get_peers(
@@ -931,18 +927,11 @@ class RelationshipManager:
         db: InfrahubDatabase,
         peer_type: type[PeerType] | None = None,  # noqa: ARG002
         branch_agnostic: bool = False,
-        include_source: bool = False,
-        include_owner: bool = False,
     ) -> Mapping[str, Node | PeerType]:
         rels = await self.get_relationships(db=db, branch_agnostic=branch_agnostic)
         peer_ids = [rel.peer_id for rel in rels if rel.peer_id]
         nodes = await registry.manager.get_many(
-            db=db,
-            ids=peer_ids,
-            branch=self.branch,
-            branch_agnostic=branch_agnostic,
-            include_source=include_source,
-            include_owner=include_owner,
+            db=db, ids=peer_ids, branch=self.branch, branch_agnostic=branch_agnostic
         )
         return nodes
 

infrahub/core/schema/generic_schema.py

@@ -51,4 +51,4 @@ class GenericSchema(GeneratedGenericSchema):
     def _get_field_names_for_diff(self) -> list[str]:
         """Exclude used_by from the diff for generic nodes"""
         fields = super()._get_field_names_for_diff()
-        return [field for field in fields if field != "used_by"]
+        return [field for field in fields if field not in ["used_by"]]

infrahub/core/schema/schema_branch.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import contextlib
 import copy
 import hashlib
 import keyword
@@ -20,7 +19,6 @@ from infrahub.core.constants import (
     OBJECT_TEMPLATE_NAME_ATTR,
     OBJECT_TEMPLATE_RELATIONSHIP_NAME,
     PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
-    PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER,
     RESERVED_ATTR_GEN_NAMES,
     RESERVED_ATTR_REL_NAMES,
     RESTRICTED_NAMESPACES,
@@ -74,16 +72,6 @@ from .schema_branch_hfid import HFIDs
 log = get_logger()
 
 
-profiles_rel_settings: dict[str, Any] = {
-    "name": "profiles",
-    "identifier": PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
-    "peer": InfrahubKind.PROFILE,
-    "kind": RelationshipKind.PROFILE,
-    "cardinality": RelationshipCardinality.MANY,
-    "branch": BranchSupportType.AWARE,
-}
-
-
 class SchemaBranch:
     def __init__(
         self,
@@ -346,8 +334,10 @@ class SchemaBranch:
             )
 
         schema: MainSchemaTypes | None = None
-        with contextlib.suppress(KeyError):
+        try:
             schema = self._cache[key]
+        except KeyError:
+            pass
 
         if not schema:
             raise ValueError(f"Schema {name!r} on branch {self.name} has incorrect hash: {key!r}")
@@ -1126,7 +1116,7 @@ class SchemaBranch:
                     ) from None
 
             for rel in node.relationships:
-                if rel.peer == InfrahubKind.GENERICGROUP:
+                if rel.peer in [InfrahubKind.GENERICGROUP]:
                     continue
                 if not self.has(rel.peer) or self.get(rel.peer, duplicate=False).state == HashableModelState.ABSENT:
                     raise ValueError(
@@ -2173,8 +2163,10 @@ class SchemaBranch:
                 or not node.generate_profile
                 or node.state == HashableModelState.ABSENT
             ):
-                with contextlib.suppress(SchemaNotFoundError):
+                try:
                     self.delete(name=self._get_profile_kind(node_kind=node.kind))
+                except SchemaNotFoundError:
+                    ...
                 continue
 
             profile = self.generate_profile_from_node(node=node)
@@ -2220,6 +2212,15 @@ class SchemaBranch:
             ):
                 continue
 
+            profiles_rel_settings: dict[str, Any] = {
+                "name": "profiles",
+                "identifier": PROFILE_NODE_RELATIONSHIP_IDENTIFIER,
+                "peer": InfrahubKind.PROFILE,
+                "kind": RelationshipKind.PROFILE,
+                "cardinality": RelationshipCardinality.MANY,
+                "branch": BranchSupportType.AWARE,
+            }
+
             # Add relationship between node and profile
             if "profiles" not in node.relationship_names:
                 node_schema = self.get(name=node_name, duplicate=True)
@@ -2284,18 +2285,6 @@ class SchemaBranch:
                 )
             ],
         )
-        if f"Template{node.kind}" in self.all_names:
-            template = self.get(name=f"Template{node.kind}", duplicate=False)
-            profile.relationships.append(
-                RelationshipSchema(
-                    name="related_templates",
-                    identifier=PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER,
-                    peer=template.kind,
-                    kind=RelationshipKind.PROFILE,
-                    cardinality=RelationshipCardinality.MANY,
-                    branch=BranchSupportType.AWARE,
-                )
-            )
 
         for node_attr in node.attributes:
             if not node_attr.support_profiles:
@@ -2426,14 +2415,6 @@ class SchemaBranch:
                 template_schema.human_friendly_id = [parent_hfid] + template_schema.human_friendly_id
                 template_schema.uniqueness_constraints[0].append(relationship.name)
 
-        if getattr(node, "generate_profile", False):
-            if "profiles" not in [r.name for r in template_schema.relationships]:
-                settings = dict(profiles_rel_settings)
-                settings["identifier"] = PROFILE_TEMPLATE_RELATIONSHIP_IDENTIFIER
-                template_schema.relationships.append(RelationshipSchema(**settings))
-
-        self.set(name=template_schema.kind, schema=template_schema)
-
     def generate_object_template_from_node(
         self, node: NodeSchema | GenericSchema, need_templates: set[NodeSchema | GenericSchema]
     ) -> TemplateSchema | GenericSchema:

infrahub/core/validators/determiner.py

@@ -1,4 +1,3 @@
-import contextlib
 from typing import TYPE_CHECKING, Any
 
 from infrahub.core.constants import RelationshipKind, SchemaPathType
@@ -85,10 +84,14 @@ class ConstraintValidatorDeterminer:
         constraints: list[SchemaUpdateConstraintInfo] = []
         schemas = list(self.schema_branch.get_all(duplicate=False).values())
         # added here to check their uniqueness constraints
-        with contextlib.suppress(SchemaNotFoundError):
+        try:
             schemas.append(self.schema_branch.get_node(name="SchemaAttribute", duplicate=False))
-        with contextlib.suppress(SchemaNotFoundError):
+        except SchemaNotFoundError:
+            pass
+        try:
             schemas.append(self.schema_branch.get_node(name="SchemaRelationship", duplicate=False))
+        except SchemaNotFoundError:
+            pass
         for schema in schemas:
             constraints.extend(await self._get_property_constraints_for_one_schema(schema=schema))
         return constraints

infrahub/database/__init__.py

@@ -356,7 +356,7 @@ class InfrahubDatabase:
                     type
                     and type == QueryType.READ
                     and runtime not in [Neo4jRuntime.DEFAULT, Neo4jRuntime.UNDEFINED]
-                    and not (self.is_transaction and runtime == Neo4jRuntime.PARALLEL)
+                    and not (self.is_transaction and runtime in [Neo4jRuntime.PARALLEL])
                 ):
                     query = f"CYPHER runtime = {runtime.value}\n" + query
                 else:

infrahub/git/base.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import contextlib
 import shutil
 from abc import ABC, abstractmethod
 from pathlib import Path
@@ -749,8 +748,10 @@ class InfrahubRepositoryBase(BaseModel, ABC):
         for short_name, branch_data in branches.items():
             branch = None
 
-            with contextlib.suppress(BranchNotFoundError):
+            try:
                 branch = registry.get_branch_from_registry(branch=short_name)
+            except BranchNotFoundError:
+                ...
 
             branch_exists_import_sync_condition = branch and (
                 branch.name not in {registry.default_branch, self.default_branch}

infrahub/graphql/loaders/peers.py

@@ -22,8 +22,6 @@ class QueryPeerParams:
     fields: dict | None = None
     at: Timestamp | str | None = None
     branch_agnostic: bool = False
-    include_source: bool = False
-    include_owner: bool = False
 
     def __hash__(self) -> int:
         frozen_fields: frozenset | None = None
@@ -41,8 +39,6 @@ class QueryPeerParams:
                 self.schema.name,
                 str(self.source_kind),
                 str(self.branch_agnostic),
-                str(self.include_source),
-                str(self.include_owner),
             ]
         )
         return hash(hash_str)
@@ -67,8 +63,6 @@ class PeerRelationshipsDataLoader(DataLoader[str, list[Relationship]]):
                 branch=self.query_params.branch,
                 branch_agnostic=self.query_params.branch_agnostic,
                 fetch_peers=True,
-                include_source=self.query_params.include_source,
-                include_owner=self.query_params.include_owner,
             )
         peer_rels_by_node_id: dict[str, list[Relationship]] = {}
         for rel in peer_rels:

infrahub/graphql/mutations/profile.py

@@ -57,8 +57,6 @@ class InfrahubProfileMutation(InfrahubMutationMixin, Mutation):
     ) -> None:
         if not node_ids:
             related_nodes = await obj.related_nodes.get_relationships(db=db)  # type: ignore[attr-defined]
-            if hasattr(obj, "related_templates"):
-                related_nodes.extend(await obj.related_templates.get_relationships(db=db))  # type: ignore[attr-defined]
             node_ids = [rel.peer_id for rel in related_nodes]
         if node_ids:
             await workflow_service.submit_workflow(
@@ -81,12 +79,7 @@ class InfrahubProfileMutation(InfrahubMutationMixin, Mutation):
 
     @classmethod
     async def _get_profile_related_node_ids(cls, db: InfrahubDatabase, obj: Node) -> set[str]:
-        related_nodes = []
-        related_nodes.extend(await obj.related_nodes.get_relationships(db=db))  # type: ignore[attr-defined]
-
-        if hasattr(obj, "related_templates"):
-            related_nodes.extend(await obj.related_templates.get_relationships(db=db))  # type: ignore[attr-defined]
-
+        related_nodes = await obj.related_nodes.get_relationships(db=db)  # type: ignore[attr-defined]
         if related_nodes:
             related_node_ids = {rel.peer_id for rel in related_nodes}
         else:

infrahub/graphql/queries/resource_manager.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import contextlib
 from typing import TYPE_CHECKING, Any
 
 from graphene import BigInt, Field, Float, Int, List, NonNull, ObjectType, String
@@ -197,8 +196,10 @@ class PoolUtilization(ObjectType):
 
         resources_map: dict[str, Node] = {}
 
-        with contextlib.suppress(SchemaNotFoundError):
+        try:
             resources_map = await pool.resources.get_peers(db=db, branch_agnostic=True)  # type: ignore[attr-defined,union-attr]
+        except SchemaNotFoundError:
+            pass
 
         utilization_getter = PrefixUtilizationGetter(
             db=db, ip_prefixes=list(resources_map.values()), at=graphql_context.at