infrahub-server 1.1.7__py3-none-any.whl → 1.2.0b1__py3-none-any.whl

infrahub/core/diff/enricher/hierarchy.py

@@ -5,29 +5,38 @@ from infrahub.core.constants import RelationshipHierarchyDirection, Relationship
 from infrahub.core.constants.database import DatabaseEdgeType
 from infrahub.core.query.node import NodeGetHierarchyQuery
 from infrahub.core.query.relationship import RelationshipGetPeerQuery, RelationshipPeerData
-from infrahub.core.schema import ProfileSchema
+from infrahub.core.schema import ProfileSchema, TemplateSchema
 from infrahub.database import InfrahubDatabase
+from infrahub.log import get_logger
 
 from ..model.path import (
     CalculatedDiffs,
     EnrichedDiffRoot,
 )
+from ..parent_node_adder import DiffParentNodeAdder, ParentNodeAddRequest
 from .interface import DiffEnricherInterface
 
+log = get_logger()
+
 
 class DiffHierarchyEnricher(DiffEnricherInterface):
     """Add hierarchy and parent/component nodes to diff even if the higher-level nodes are unchanged"""
 
-    def __init__(self, db: InfrahubDatabase):
+    def __init__(self, db: InfrahubDatabase, parent_adder: DiffParentNodeAdder):
         self.db = db
+        self.parent_adder = parent_adder
 
     async def enrich(
-        self, enriched_diff_root: EnrichedDiffRoot, calculated_diffs: CalculatedDiffs | None = None
+        self,
+        enriched_diff_root: EnrichedDiffRoot,
+        calculated_diffs: CalculatedDiffs | None = None,  # noqa: ARG002
     ) -> None:
         # A hierarchy can be defined in 2 ways
         # - A node has a relationship of kind parent
         # - A node is part of a hierarchy
 
+        log.info("Beginning hierarchical diff enrichment...")
+        self.parent_adder.initialize(enriched_diff_root=enriched_diff_root)
         node_rel_parent_map: dict[str, list[str]] = defaultdict(list)
         node_hierarchy_map: dict[str, list[str]] = defaultdict(list)
 
@@ -36,7 +45,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
                 name=node.kind, branch=enriched_diff_root.diff_branch_name, duplicate=False
             )
 
-            if isinstance(schema_node, ProfileSchema):
+            if isinstance(schema_node, ProfileSchema | TemplateSchema):
                 continue
 
             if schema_node.has_parent_relationship:
@@ -53,6 +62,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
 
         await self._enrich_nodes_with_parent(enriched_diff_root=enriched_diff_root, node_map=node_rel_parent_map)
         await self._enrich_hierarchical_nodes(enriched_diff_root=enriched_diff_root, node_map=node_hierarchy_map)
+        log.info("Hierarchical diff enrichment complete.")
 
     async def _enrich_hierarchical_nodes(
         self,
@@ -63,6 +73,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
 
         # Retrieve the ID of all ancestors
         for kind, node_ids in node_map.items():
+            log.info(f"Beginning hierarchy enrichment for {kind} node, num_nodes={len(node_ids)}...")
             hierarchy_schema = self.db.schema.get(
                 name=kind, branch=enriched_diff_root.diff_branch_name, duplicate=False
             )
@@ -87,7 +98,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
 
                 current_node = node
                 for ancestor in ancestors:
-                    parent = enriched_diff_root.add_parent(
+                    parent_request = ParentNodeAddRequest(
                         node_id=current_node.uuid,
                         parent_id=str(ancestor.uuid),
                         parent_kind=ancestor.kind,
@@ -97,6 +108,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
                         parent_rel_cardinality=parent_rel.cardinality,
                         parent_rel_label=parent_rel.label or "",
                     )
+                    parent = self.parent_adder.add_parent(parent_request=parent_request)
 
                     current_node = parent
 
@@ -114,6 +126,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
 
         # Query the UUID of the parent
         for kind, ids in node_map.items():
+            log.info(f"Beginning parent enrichment for {kind} node, num_nodes={len(ids)}...")
             schema_node = self.db.schema.get(name=kind, branch=enriched_diff_root.diff_branch_name, duplicate=False)
 
             parent_rel = [rel for rel in schema_node.relationships if rel.kind == RelationshipKind.PARENT][0]
@@ -138,15 +151,16 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
         # Check if the parent are already present
         # If parent is already in the list of node we need to add a relationship
         # If parent is not in the list of node, we need to add it
+        diff_node_map = enriched_diff_root.get_node_map(node_uuids=set(parent_peers.keys()))
         for node_id, peer_parent in parent_peers.items():
             # TODO check if we can optimize this part to avoid querying this multiple times
-            node = enriched_diff_root.get_node(node_uuid=node_id)
+            node = diff_node_map[node_id]
             schema_node = self.db.schema.get(
                 name=node.kind, branch=enriched_diff_root.diff_branch_name, duplicate=False
             )
             parent_rel = [rel for rel in schema_node.relationships if rel.kind == RelationshipKind.PARENT][0]
 
-            enriched_diff_root.add_parent(
+            parent_request = ParentNodeAddRequest(
                 node_id=node.uuid,
                 parent_id=str(peer_parent.peer_id),
                 parent_kind=peer_parent.peer_kind,
@@ -156,6 +170,7 @@ class DiffHierarchyEnricher(DiffEnricherInterface):
                 parent_rel_cardinality=parent_rel.cardinality,
                 parent_rel_label=parent_rel.label or "",
             )
+            self.parent_adder.add_parent(parent_request=parent_request)
 
         if node_parent_with_parent_map:
             await self._enrich_nodes_with_parent(

infrahub/core/diff/enricher/labels.py

@@ -6,6 +6,7 @@ from infrahub.core.constants import DiffAction
 from infrahub.core.constants.database import DatabaseEdgeType
 from infrahub.core.query.node import NodeGetKindQuery
 from infrahub.database import InfrahubDatabase
+from infrahub.log import get_logger
 
 from ..model.path import (
     CalculatedDiffs,
@@ -17,6 +18,8 @@ from ..model.path import (
 from ..payload_builder import get_display_labels
 from .interface import DiffEnricherInterface
 
+log = get_logger()
+
 PROPERTY_TYPES_WITH_LABELS = {DatabaseEdgeType.IS_RELATED, DatabaseEdgeType.HAS_OWNER, DatabaseEdgeType.HAS_SOURCE}
 
 
@@ -191,9 +194,10 @@ class DiffLabelsEnricher(DiffEnricherInterface):
     async def enrich(
         self,
         enriched_diff_root: EnrichedDiffRoot,
-        calculated_diffs: CalculatedDiffs | None = None,
+        calculated_diffs: CalculatedDiffs | None = None,  # noqa: ARG002
         conflicts_only: bool = False,
     ) -> None:
+        log.info("Beginning display labels diff enrichment...")
         self._base_branch_name = enriched_diff_root.base_branch_name
         self._diff_branch_name = enriched_diff_root.diff_branch_name
         self._conflicts_only = conflicts_only
@@ -214,3 +218,4 @@ class DiffLabelsEnricher(DiffEnricherInterface):
             ...
 
         self._update_relationship_labels(enriched_diff=enriched_diff_root)
+        log.info("Display labels diff enrichment complete.")

infrahub/core/diff/enricher/path_identifier.py

@@ -1,10 +1,13 @@
 from infrahub.core.constants import PathType
 from infrahub.core.path import DataPath
 from infrahub.database import InfrahubDatabase
+from infrahub.log import get_logger
 
 from ..model.path import CalculatedDiffs, EnrichedDiffRoot
 from .interface import DiffEnricherInterface
 
+log = get_logger()
+
 
 class DiffPathIdentifierEnricher(DiffEnricherInterface):
     """Add path identifiers to every element in the diff"""
@@ -19,7 +22,7 @@ class DiffPathIdentifierEnricher(DiffEnricherInterface):
             raise RuntimeError("diff_branch_name not set")
         return self._diff_branch_name
 
-    async def enrich(self, enriched_diff_root: EnrichedDiffRoot, calculated_diffs: CalculatedDiffs) -> None:
+    async def enrich(self, enriched_diff_root: EnrichedDiffRoot, calculated_diffs: CalculatedDiffs) -> None:  # noqa: ARG002
         self._diff_branch_name = enriched_diff_root.diff_branch_name
         for node in enriched_diff_root.nodes:
             node_path = DataPath(
@@ -62,3 +65,4 @@ class DiffPathIdentifierEnricher(DiffEnricherInterface):
                         relationship_property_path = relationship_element_path.model_copy()
                         relationship_property_path.property_name = relationship_property.property_type.value
                         relationship_property.path_identifier = relationship_property_path.get_path(with_peer=False)
+        log.info("Path identifier diff enrichment complete.")

infrahub/core/diff/enricher/summary_counts.py

@@ -0,0 +1,107 @@
+from collections import Counter
+from typing import Iterable
+
+from infrahub.core.constants import DiffAction
+
+from ..model.path import (
+    BaseSummary,
+    CalculatedDiffs,
+    EnrichedDiffAttribute,
+    EnrichedDiffNode,
+    EnrichedDiffRelationship,
+    EnrichedDiffRoot,
+    EnrichedDiffSingleRelationship,
+)
+from .interface import DiffEnricherInterface
+
+
+class DiffSummaryCountsEnricher(DiffEnricherInterface):
+    async def enrich(
+        self,
+        enriched_diff_root: EnrichedDiffRoot,
+        calculated_diffs: CalculatedDiffs | None = None,  # noqa: ARG002
+    ) -> None:
+        self._add_root_summaries(diff_root=enriched_diff_root)
+
+    def _add_summary(self, summary_node: BaseSummary, actions: Iterable[DiffAction]) -> None:
+        summary_count = Counter(actions)
+        summary_node.num_added = summary_count.get(DiffAction.ADDED, 0)
+        summary_node.num_updated = summary_count.get(DiffAction.UPDATED, 0)
+        summary_node.num_removed = summary_count.get(DiffAction.REMOVED, 0)
+
+    def _add_root_summaries(self, diff_root: EnrichedDiffRoot) -> None:
+        contains_conflict = False
+        num_conflicts = 0
+        for diff_node in diff_root.nodes:
+            contains_conflict |= self._add_node_summaries(diff_node=diff_node)
+            if diff_node.conflict or diff_node.contains_conflict:
+                num_conflicts += 1
+        self._add_summary(summary_node=diff_root, actions=(n.action for n in diff_root.nodes))
+        diff_root.contains_conflict = contains_conflict
+        diff_root.num_conflicts = num_conflicts
+        self._add_child_nodes_to_summaries(diff_root=diff_root)
+
+    def _add_node_summaries(self, diff_node: EnrichedDiffNode) -> bool:
+        contains_conflict = False
+        num_conflicts = 0
+        for diff_attr in diff_node.attributes:
+            contains_conflict |= self._add_attribute_summaries(diff_attribute=diff_attr)
+            if diff_attr.contains_conflict:
+                num_conflicts += 1
+        for diff_rel in diff_node.relationships:
+            contains_conflict |= self._add_relationship_summaries(diff_relationship=diff_rel)
+            if diff_rel.contains_conflict:
+                num_conflicts += 1
+        self._add_summary(
+            summary_node=diff_node, actions=(field.action for field in diff_node.relationships | diff_node.attributes)
+        )
+        diff_node.contains_conflict = contains_conflict
+        diff_node.num_conflicts = num_conflicts
+        return contains_conflict
+
+    def _add_attribute_summaries(self, diff_attribute: EnrichedDiffAttribute) -> bool:
+        contains_conflict = False
+        num_conflicts = 0
+        for diff_prop in diff_attribute.properties:
+            if diff_prop.conflict:
+                num_conflicts += 1
+                contains_conflict = True
+        self._add_summary(summary_node=diff_attribute, actions=(p.action for p in diff_attribute.properties))
+        diff_attribute.contains_conflict = contains_conflict
+        diff_attribute.num_conflicts = num_conflicts
+        return contains_conflict
+
+    def _add_relationship_summaries(self, diff_relationship: EnrichedDiffRelationship) -> bool:
+        contains_conflict = False
+        num_conflicts = 0
+        for diff_element in diff_relationship.relationships:
+            contains_conflict |= self._add_element_summaries(diff_element=diff_element)
+            if diff_element.conflict:
+                num_conflicts += 1
+        self._add_summary(summary_node=diff_relationship, actions=(e.action for e in diff_relationship.relationships))
+        diff_relationship.contains_conflict = contains_conflict
+        diff_relationship.num_conflicts = num_conflicts
+        return contains_conflict
+
+    def _add_element_summaries(self, diff_element: EnrichedDiffSingleRelationship) -> bool:
+        if diff_element.conflict is None:
+            contains_conflict = False
+            num_conflicts = 0
+        else:
+            contains_conflict = True
+            num_conflicts = 1
+        for diff_prop in diff_element.properties:
+            if diff_prop.conflict:
+                num_conflicts += 1
+                contains_conflict = True
+        self._add_summary(summary_node=diff_element, actions=(p.action for p in diff_element.properties))
+        diff_element.contains_conflict = contains_conflict
+        diff_element.num_conflicts = num_conflicts
+        return contains_conflict
+
+    def _add_child_nodes_to_summaries(self, diff_root: EnrichedDiffRoot) -> None:
+        for diff_node in diff_root.nodes:
+            for diff_rel in diff_node.relationships:
+                if not diff_rel.contains_conflict:
+                    diff_rel.contains_conflict = any(n.contains_conflict for n in diff_rel.nodes)
+                diff_rel.num_conflicts += sum(bool(n.contains_conflict or n.conflict) for n in diff_rel.nodes)

infrahub/core/diff/merger/merger.py

@@ -9,6 +9,7 @@ from infrahub.log import get_logger
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
+    from infrahub.core.diff.model.path import EnrichedDiffRoot
     from infrahub.core.diff.repository.repository import DiffRepository
     from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
@@ -33,7 +34,7 @@ class DiffMerger:
         self.diff_repository = diff_repository
         self.serializer = serializer
 
-    async def merge_graph(self, at: Timestamp) -> None:
+    async def merge_graph(self, at: Timestamp) -> EnrichedDiffRoot:
         tracking_id = BranchTrackingId(name=self.source_branch.name)
         enriched_diffs = await self.diff_repository.get_roots_metadata(
             diff_branch_names=[self.source_branch.name],
@@ -77,6 +78,7 @@ class DiffMerger:
         self.source_branch.branched_from = at.to_string()
         await self.source_branch.save(db=self.db)
         registry.branch[self.source_branch.name] = self.source_branch
+        return enriched_diff
 
     async def rollback(self, at: Timestamp) -> None:
         rollback_query = await DiffMergeRollbackQuery.init(

infrahub/core/diff/model/path.py

@@ -20,7 +20,7 @@ if TYPE_CHECKING:
     from neo4j.graph import Node as Neo4jNode
     from neo4j.graph import Path as Neo4jPath
     from neo4j.graph import Relationship as Neo4jRelationship
-    from pendulum import Interval
+    from whenever import TimeDelta
 
     from infrahub.graphql.initialization import GraphqlContext
 
@@ -163,6 +163,10 @@ class EnrichedDiffAttribute(BaseSummary):
     def __hash__(self) -> int:
         return hash(self.name)
 
+    @property
+    def num_properties(self) -> int:
+        return len(self.properties)
+
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
         return {prop.path_identifier: prop.conflict for prop in self.properties if prop.conflict}
 
@@ -202,6 +206,10 @@ class EnrichedDiffSingleRelationship(BaseSummary):
     def __hash__(self) -> int:
         return hash(self.peer_id)
 
+    @property
+    def num_properties(self) -> int:
+        return len(self.properties)
+
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
         all_conflicts: dict[str, EnrichedDiffConflict] = {}
         if self.conflict:
@@ -248,6 +256,10 @@ class EnrichedDiffRelationship(BaseSummary):
     def __hash__(self) -> int:
         return hash(self.name)
 
+    @property
+    def num_properties(self) -> int:
+        return sum(r.num_properties for r in self.relationships)
+
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
         all_conflicts: dict[str, EnrichedDiffConflict] = {}
         for element in self.relationships:
@@ -308,6 +320,10 @@ class EnrichedDiffNode(BaseSummary):
     def __hash__(self) -> int:
         return hash(self.uuid)
 
+    @property
+    def num_properties(self) -> int:
+        return sum(a.num_properties for a in self.attributes) + sum(r.num_properties for r in self.relationships)
+
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
         all_conflicts: dict[str, EnrichedDiffConflict] = {}
         if self.conflict:
@@ -325,18 +341,18 @@ class EnrichedDiffNode(BaseSummary):
             rel.clear_conflicts()
         self.conflict = None
 
-    def get_parent_info(self, context: GraphqlContext | None = None) -> ParentNodeInfo | None:
+    def get_parent_info(self, graphql_context: GraphqlContext | None = None) -> ParentNodeInfo | None:
         for r in self.relationships:
             for n in r.nodes:
                 relationship_name: str = "undefined"
 
-                if not context:
+                if not graphql_context:
                     return ParentNodeInfo(node=n, relationship_name=relationship_name)
 
-                node_schema = context.db.schema.get(name=self.kind)
+                node_schema = graphql_context.db.schema.get(name=self.kind)
                 rel_schema = node_schema.get_relationship(name=r.name)
 
-                parent_schema = context.db.schema.get(name=n.kind)
+                parent_schema = graphql_context.db.schema.get(name=n.kind)
                 rels_parent = parent_schema.get_relationships_by_identifier(id=rel_schema.get_identifier())
 
                 if rels_parent and len(rels_parent) == 1:
@@ -409,16 +425,16 @@ class EnrichedDiffRootMetadata(BaseSummary):
     from_time: Timestamp
     to_time: Timestamp
     uuid: str
-    partner_uuid: str
     tracking_id: TrackingId
+    partner_uuid: str | None = field(default=None)
     exists_on_database: bool = field(default=False)
 
     def __hash__(self) -> int:
         return hash(self.uuid)
 
     @property
-    def time_range(self) -> Interval:
-        return self.to_time.obj - self.from_time.obj
+    def time_range(self) -> TimeDelta:
+        return self.to_time.get_obj() - self.from_time.get_obj()
 
     def update_metadata(
         self,
@@ -447,8 +463,8 @@ class EnrichedDiffRoot(EnrichedDiffRootMetadata):
         return hash(self.uuid)
 
     @property
-    def time_range(self) -> Interval:
-        return self.to_time.obj - self.from_time.obj
+    def time_range(self) -> TimeDelta:
+        return self.to_time.get_obj() - self.from_time.get_obj()
 
     def get_nodes_without_parents(self) -> set[EnrichedDiffNode]:
         nodes_with_parent_uuids = set()
@@ -470,6 +486,13 @@ class EnrichedDiffRoot(EnrichedDiffRootMetadata):
         except ValueError:
             return False
 
+    def get_node_map(self, node_uuids: set[str] | None = None) -> dict[str, EnrichedDiffNode]:
+        node_map = {}
+        for node in self.nodes:
+            if node_uuids is None or node.uuid in node_uuids:
+                node_map[node.uuid] = node
+        return node_map
+
     def get_all_conflicts(self) -> dict[str, EnrichedDiffConflict]:
         all_conflicts: dict[str, EnrichedDiffConflict] = {}
         for node in self.nodes:
@@ -692,7 +715,7 @@ class DiffRoot:
 
 
 @dataclass
-class DatabasePath:  # pylint: disable=too-many-public-methods
+class DatabasePath:
     root_node: Neo4jNode
     path_to_node: Neo4jRelationship
     node_node: Neo4jNode

infrahub/core/diff/parent_node_adder.py

@@ -0,0 +1,78 @@
+from dataclasses import dataclass, field
+
+from infrahub.core.constants import DiffAction, RelationshipCardinality
+
+from .model.path import EnrichedDiffNode, EnrichedDiffRelationship, EnrichedDiffRoot
+
+
+@dataclass
+class ParentNodeAddRequest:
+    node_id: str
+    parent_id: str
+    parent_kind: str
+    parent_label: str
+    parent_rel_name: str
+    parent_rel_identifier: str
+    parent_rel_cardinality: RelationshipCardinality
+    parent_rel_label: str = field(default="")
+
+
+class DiffParentNodeAdder:
+    def __init__(self) -> None:
+        self._diff_root: EnrichedDiffRoot | None = None
+        self._node_map: dict[str, EnrichedDiffNode] = {}
+
+    def initialize(self, enriched_diff_root: EnrichedDiffRoot) -> None:
+        self._diff_root = enriched_diff_root
+        self._node_map = enriched_diff_root.get_node_map()
+
+    def get_root(self) -> EnrichedDiffRoot:
+        if not self._diff_root:
+            raise RuntimeError("Must call initialize before using")
+        return self._diff_root
+
+    def get_node(self, node_uuid: str) -> EnrichedDiffNode:
+        return self._node_map[node_uuid]
+
+    def has_node(self, node_uuid: str) -> bool:
+        return node_uuid in self._node_map
+
+    def add_node(self, node: EnrichedDiffNode) -> None:
+        if node.uuid in self._node_map:
+            return
+        self._node_map[node.uuid] = node
+        self.get_root().nodes.add(node)
+
+    def add_parent(self, parent_request: ParentNodeAddRequest) -> EnrichedDiffNode:
+        if not self._diff_root:
+            raise RuntimeError("Must call initialize before using")
+        node = self.get_node(node_uuid=parent_request.node_id)
+        if not self.has_node(node_uuid=parent_request.parent_id):
+            parent = EnrichedDiffNode(
+                uuid=parent_request.parent_id,
+                kind=parent_request.parent_kind,
+                label=parent_request.parent_label,
+                action=DiffAction.UNCHANGED,
+                changed_at=None,
+            )
+            self.add_node(parent)
+        else:
+            parent = self.get_node(node_uuid=parent_request.parent_id)
+
+        try:
+            rel = node.get_relationship(name=parent_request.parent_rel_name)
+            rel.nodes.add(parent)
+        except ValueError:
+            node.relationships.add(
+                EnrichedDiffRelationship(
+                    name=parent_request.parent_rel_name,
+                    identifier=parent_request.parent_rel_identifier,
+                    label=parent_request.parent_rel_label,
+                    cardinality=parent_request.parent_rel_cardinality,
+                    changed_at=None,
+                    action=DiffAction.UNCHANGED,
+                    nodes={parent},
+                )
+            )
+
+        return parent

infrahub/core/diff/payload_builder.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+from infrahub import config
 from infrahub.core.manager import NodeManager
 from infrahub.core.registry import registry
 from infrahub.exceptions import SchemaNotFoundError
@@ -26,8 +27,18 @@ async def get_display_labels_per_kind(
         if skip_missing_schema:
             return {}
         raise
-    nodes = await NodeManager.get_many(ids=ids, fields=fields, db=db, branch=branch)
-    return {node_id: await node.render_display_label(db=db) for node_id, node in nodes.items()}
+    display_label_map: dict[str, str] = {}
+    offset = 0
+    limit = config.SETTINGS.database.query_size_limit
+    while True:
+        limited_ids = ids[offset : offset + limit]
+        if not limited_ids:
+            break
+        node_map = await NodeManager.get_many(ids=limited_ids, fields=fields, db=db, branch=branch)
+        for node_id, node in node_map.items():
+            display_label_map[node_id] = await node.render_display_label(db=db)
+        offset += limit
+    return display_label_map
 
 
 async def get_display_labels(nodes: dict[str, dict[str, list[str]]], db: InfrahubDatabase) -> dict[str, dict[str, str]]:

infrahub/core/diff/query/all_conflicts.py

@@ -24,7 +24,7 @@ class EnrichedDiffAllConflictsQuery(Query):
         if self.tracking_id is None and self.diff_id is None:
             raise RuntimeError("tracking_id or diff_id is required")
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "diff_branch_name": self.diff_branch_name,
             "diff_id": self.diff_id,

infrahub/core/diff/query/artifact.py

@@ -22,7 +22,7 @@ class ArtifactDiffQuery(Query):
         self.target_rel_identifier = target_rel_identifier
         self.definition_rel_identifier = definition_rel_identifier
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         source_branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
         self.params.update(branch_params)
 

infrahub/core/diff/query/delete_query.py

@@ -13,7 +13,7 @@ class EnrichedDiffDeleteQuery(Query):
         super().__init__(**kwargs)
         self.enriched_diff_root_uuids = enriched_diff_root_uuids
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {"diff_root_uuids": self.enriched_diff_root_uuids}
         query = """
         MATCH (d_root:DiffRoot)

infrahub/core/diff/query/diff_get.py

@@ -52,7 +52,7 @@ class EnrichedDiffGetQuery(Query):
         self.diff_ids = diff_ids
         self.filters = filters or EnrichedDiffQueryFilters()
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "base_branch": self.base_branch_name,
             "diff_branches": self.diff_branch_names,

infrahub/core/diff/query/diff_summary.py

@@ -61,7 +61,7 @@ class DiffSummaryQuery(Query):
         self.to_time = to_time
         self.tracking_id = tracking_id
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         if (self.from_time is None or self.to_time is None) and self.tracking_id is None:
             raise ValueError("DiffSummaryQuery requires from_time and to_time or tracking_id ")
         self.params = {

infrahub/core/diff/query/field_specifiers.py

@@ -12,7 +12,7 @@ class EnrichedDiffFieldSpecifiersQuery(Query):
         super().__init__(**kwargs)
         self.diff_id = diff_id
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params["diff_id"] = self.diff_id
         query = """
 CALL {

infrahub/core/diff/query/field_summary.py

@@ -27,7 +27,7 @@ class EnrichedDiffNodeFieldSummaryQuery(Query):
         self.tracking_id = tracking_id
         self.diff_id = diff_id
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         if self.tracking_id is None and self.diff_id is None:
             raise RuntimeError("Either tacking_id or diff_id is required")
         self.params = {

infrahub/core/diff/query/filters.py

@@ -16,8 +16,8 @@ class IncExclFilterOptions(BaseModel):
 
 
 class IncExclActionFilterOptions(BaseModel):
-    includes: set[DiffAction] = Field(default_factory=list)
-    excludes: set[DiffAction] = Field(default_factory=list)
+    includes: set[DiffAction] = Field(default_factory=set)
+    excludes: set[DiffAction] = Field(default_factory=set)
 
     @property
     def is_empty(self) -> bool:

infrahub/core/diff/query/get_conflict_query.py

@@ -14,7 +14,7 @@ class EnrichedDiffConflictQuery(Query):
         super().__init__(**kwargs)
         self.conflict_id = conflict_id
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {"conflict_id": self.conflict_id}
         query = "MATCH (conflict:DiffConflict {uuid: $conflict_id})"
         self.return_labels = ["conflict"]

infrahub/core/diff/query/has_conflicts_query.py

@@ -25,7 +25,7 @@ class EnrichedDiffHasConflictQuery(Query):
         self.tracking_id = tracking_id
         self.diff_id = diff_id
 
-    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:
+    async def query_init(self, db: InfrahubDatabase, **kwargs: Any) -> None:  # noqa: ARG002
         self.params = {
             "diff_branch_name": self.diff_branch_name,
             "tracking_id": self.tracking_id.serialize() if self.tracking_id else None,