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

infrahub/core/schema/basenode_schema.py

@@ -5,7 +5,7 @@ import keyword
 import os
 from dataclasses import asdict, dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, Optional, Union, overload
+from typing import TYPE_CHECKING, Any, Callable, Iterable, Literal, overload
 
 from infrahub_sdk.utils import compare_lists, intersection
 from pydantic import field_validator
@@ -25,6 +25,7 @@ if TYPE_CHECKING:
 
 
 NODE_METADATA_ATTRIBUTES = ["_source", "_owner"]
+INHERITED = "INHERITED"
 
 
 class BaseNodeSchema(GeneratedBaseNodeSchema):
@@ -120,7 +121,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         other: Self,
         get_func: Callable,
         get_map_func: Callable,
-        obj_type: type[Union[AttributeSchema, RelationshipSchema]],
+        obj_type: type[AttributeSchema | RelationshipSchema],
     ) -> HashableModelDiff:
         """The goal of this function is to reduce the amount of code duplicated between Attribute and Relationship to calculate a diff
         The logic is the same for both, except that the functions we are using to access these objects are differents
@@ -138,8 +139,8 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         reversed_map_other = dict(map(reversed, other_map.items()))
 
         # Identify which elements are using the same id on both sides
-        clean_local_ids = [id for id in local_map.values() if id is not None]
-        clean_other_ids = [id for id in other_map.values() if id is not None]
+        clean_local_ids = [id for id in local_map.values() if id is not None and id != INHERITED]
+        clean_other_ids = [id for id in other_map.values() if id is not None and id != INHERITED]
         shared_ids = intersection(list1=clean_local_ids, list2=clean_other_ids)
 
         # Identify which elements are present on both side based on the name
@@ -176,16 +177,14 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         return elements_diff
 
     @overload
-    def get_field(
-        self, name: str, raise_on_error: Literal[True] = True
-    ) -> Union[AttributeSchema, RelationshipSchema]: ...
+    def get_field(self, name: str, raise_on_error: Literal[True] = True) -> AttributeSchema | RelationshipSchema: ...
 
     @overload
     def get_field(
         self, name: str, raise_on_error: Literal[False] = False
-    ) -> Optional[Union[AttributeSchema, RelationshipSchema]]: ...
+    ) -> AttributeSchema | RelationshipSchema | None: ...
 
-    def get_field(self, name: str, raise_on_error: bool = True) -> Optional[Union[AttributeSchema, RelationshipSchema]]:
+    def get_field(self, name: str, raise_on_error: bool = True) -> AttributeSchema | RelationshipSchema | None:
         if field := self.get_attribute_or_none(name=name):
             return field
 
@@ -204,7 +203,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
 
         raise ValueError(f"Unable to find the attribute {name}")
 
-    def get_attribute_or_none(self, name: str) -> Optional[AttributeSchema]:
+    def get_attribute_or_none(self, name: str) -> AttributeSchema | None:
         for item in self.attributes:
             if item.name == name:
                 return item
@@ -230,7 +229,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
 
         raise ValueError(f"Unable to find the relationship with the ID: {id}")
 
-    def get_relationship_or_none(self, name: str) -> Optional[RelationshipSchema]:
+    def get_relationship_or_none(self, name: str) -> RelationshipSchema | None:
         for item in self.relationships:
             if item.name == name:
                 return item
@@ -242,9 +241,9 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
     @overload
     def get_relationship_by_identifier(
         self, id: str, raise_on_error: Literal[False] = False
-    ) -> Optional[RelationshipSchema]: ...
+    ) -> RelationshipSchema | None: ...
 
-    def get_relationship_by_identifier(self, id: str, raise_on_error: bool = True) -> Optional[RelationshipSchema]:
+    def get_relationship_by_identifier(self, id: str, raise_on_error: bool = True) -> RelationshipSchema | None:
         for item in self.relationships:
             if item.identifier == id:
                 return item
@@ -269,13 +268,13 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
     def get_attributes_name_id_map(self) -> dict[str, str]:
         name_id_map = {}
         for attr in self.attributes:
-            name_id_map[attr.name] = attr.id
+            name_id_map[attr.name] = INHERITED if attr.inherited else attr.id
         return name_id_map
 
     def get_relationship_name_id_map(self) -> dict[str, str]:
         name_id_map = {}
         for rel in self.relationships:
-            name_id_map[rel.name] = rel.id
+            name_id_map[rel.name] = INHERITED if rel.inherited else rel.id
         return name_id_map
 
     @property
@@ -343,7 +342,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
             fields[subpaths[0]] = cls.convert_path_to_graphql_fields(path=subpaths[1])
         return fields
 
-    def generate_fields_for_display_label(self) -> Optional[dict]:
+    def generate_fields_for_display_label(self) -> dict | None:
         """Generate a dictionary containing the list of fields that are required
         to generate the display_label.
 
@@ -353,12 +352,12 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         if not self.display_labels:
             return None
 
-        fields: dict[str, Union[str, None, dict[str, None]]] = {}
+        fields: dict[str, str | None | dict[str, None]] = {}
         for item in self.display_labels:
             fields.update(self.convert_path_to_graphql_fields(path=item))
         return fields
 
-    def generate_fields_for_hfid(self) -> Optional[dict]:
+    def generate_fields_for_hfid(self) -> dict | None:
         """Generate a dictionary containing the list of fields that are required
         to generate the hfid.
 
@@ -368,7 +367,7 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
         if not self.human_friendly_id:
             return None
 
-        fields: dict[str, Union[str, None, dict[str, None]]] = {}
+        fields: dict[str, str | None | dict[str, None]] = {}
         for item in self.human_friendly_id:
             fields.update(self.convert_path_to_graphql_fields(path=item))
         return fields
@@ -381,11 +380,11 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
 
         return value
 
-    def parse_schema_path(self, path: str, schema: Optional[SchemaBranch] = None) -> SchemaAttributePath:
+    def parse_schema_path(self, path: str, schema: SchemaBranch | None = None) -> SchemaAttributePath:
         schema_path = SchemaAttributePath()
-        relationship_piece: Optional[str] = None
-        attribute_piece: Optional[str] = None
-        property_piece: Optional[str] = None
+        relationship_piece: str | None = None
+        attribute_piece: str | None = None
+        property_piece: str | None = None
 
         path_parts = path.split("__")
         if path_parts[0] in self.relationship_names:
@@ -434,33 +433,79 @@ class BaseNodeSchema(GeneratedBaseNodeSchema):
     def get_unique_constraint_schema_attribute_paths(
         self,
         schema_branch: SchemaBranch,
-        include_unique_attributes: bool = False,
-    ) -> list[list[SchemaAttributePath]]:
-        constraint_paths_groups = []
-        if include_unique_attributes:
-            for attribute_schema in self.unique_attributes:
-                constraint_paths_groups.append(
-                    [SchemaAttributePath(attribute_schema=attribute_schema, attribute_property_name="value")]
-                )
-
-        if not self.uniqueness_constraints:
-            return constraint_paths_groups
+    ) -> list[SchemaUniquenessConstraintPath]:
+        if self.uniqueness_constraints is None:
+            return []
+
+        uniqueness_constraint_paths = []
 
         for uniqueness_path_group in self.uniqueness_constraints:
-            constraint_paths_group = []
-            for uniqueness_path_part in uniqueness_path_group:
-                constraint_paths_group.append(self.parse_schema_path(path=uniqueness_path_part, schema=schema_branch))
-            if constraint_paths_group not in constraint_paths_groups:
-                constraint_paths_groups.append(constraint_paths_group)
-        return constraint_paths_groups
+            attributes_paths = [
+                self.parse_schema_path(path=uniqueness_path_part, schema=schema_branch)
+                for uniqueness_path_part in uniqueness_path_group
+            ]
+            uniqueness_constraint_type = self.get_uniqueness_constraint_type(
+                uniqueness_constraint=set(uniqueness_path_group), schema_branch=schema_branch
+            )
+            uniqueness_constraint_path = SchemaUniquenessConstraintPath(
+                attributes_paths=attributes_paths, typ=uniqueness_constraint_type
+            )
+            uniqueness_constraint_paths.append(uniqueness_constraint_path)
+
+        return uniqueness_constraint_paths
+
+    def convert_hfid_to_uniqueness_constraint(self, schema_branch: SchemaBranch) -> list[str] | None:
+        if self.human_friendly_id is None:
+            return None
+
+        uniqueness_constraint = []
+        for item in self.human_friendly_id:
+            schema_attribute_path = self.parse_schema_path(path=item, schema=schema_branch)
+            if schema_attribute_path.is_type_attribute:
+                uniqueness_constraint.append(item)
+            elif schema_attribute_path.is_type_relationship:
+                uniqueness_constraint.append(schema_attribute_path.relationship_schema.name)
+        return uniqueness_constraint
+
+    def get_uniqueness_constraint_type(
+        self, uniqueness_constraint: set[str], schema_branch: SchemaBranch
+    ) -> UniquenessConstraintType:
+        hfid = self.convert_hfid_to_uniqueness_constraint(schema_branch=schema_branch)
+        if hfid is None:
+            return UniquenessConstraintType.STANDARD
+        hfid_set = set(hfid)
+        if uniqueness_constraint == hfid_set:
+            return UniquenessConstraintType.HFID
+        if uniqueness_constraint <= hfid_set:
+            return UniquenessConstraintType.SUBSET_OF_HFID
+        return UniquenessConstraintType.STANDARD
+
+
+@dataclass
+class SchemaUniquenessConstraintPath:
+    attributes_paths: list[SchemaAttributePath]
+    typ: UniquenessConstraintType
+
+
+class UniquenessConstraintType(Enum):
+    HFID = "HFID"
+    SUBSET_OF_HFID = "SUBSET_OF_HFID"
+    STANDARD = "STANDARD"
+
+
+@dataclass
+class UniquenessConstraintViolation:
+    nodes_ids: set[str]
+    fields: list[str]
+    typ: UniquenessConstraintType
 
 
 @dataclass
 class SchemaAttributePath:
-    relationship_schema: Optional[RelationshipSchema] = None
-    related_schema: Optional[Union[NodeSchema, GenericSchema]] = None
-    attribute_schema: Optional[AttributeSchema] = None
-    attribute_property_name: Optional[str] = None
+    relationship_schema: RelationshipSchema | None = None
+    related_schema: NodeSchema | GenericSchema | None = None
+    attribute_schema: AttributeSchema | None = None
+    attribute_property_name: str | None = None
 
     @property
     def is_type_attribute(self) -> bool:
@@ -492,6 +537,10 @@ class SchemaAttributePath:
             return self.attribute_property_name
         raise AttributePathParsingError("An attribute_property_name was expected but not found")
 
+    @property
+    def attribute_path_as_str(self) -> str:
+        return self.active_attribute_schema.name + "__" + self.active_attribute_property_name
+
 
 @dataclass
 class SchemaAttributePathValue(SchemaAttributePath):

infrahub/core/schema/computed_attribute.py

@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any
 
 from pydantic import ConfigDict, Field, model_serializer
 
@@ -8,10 +8,10 @@ from infrahub.core.models import HashableModel
 
 class ComputedAttribute(HashableModel):
     kind: ComputedAttributeKind
-    jinja2_template: Optional[str] = Field(
+    jinja2_template: str | None = Field(
         default=None, description="The Jinja2 template in string format, required when assignment_type=jinja2"
     )
-    transform: Optional[str] = Field(
+    transform: str | None = Field(
         default=None, description="The Python Transform name or ID, required when assignment_type=transform"
     )
 

infrahub/core/schema/definitions/core/__init__.py

@@ -1,5 +1,7 @@
 from typing import Any
 
+from ...generic_schema import GenericSchema
+from ...node_schema import NodeSchema
 from .account import (
     core_account,
     core_account_token,
@@ -11,6 +13,7 @@ from .account import (
 from .artifact import core_artifact, core_artifact_definition, core_artifact_target
 from .builtin import builtin_tag
 from .check import core_check_definition
+from .core import core_node, core_task_target
 from .generator import core_generator_definition, core_generator_instance
 from .graphql_query import core_graphql_query
 from .group import core_generator_group, core_graphql_query_group, core_group, core_standard_group
@@ -54,27 +57,11 @@ from .propose_change_validator import (
 )
 from .repository import core_generic_repository, core_read_only_repository, core_repository
 from .resource_pool import core_ip_address_pool, core_ip_prefix_pool, core_number_pool, core_resource_pool
-from .template import core_object_template
+from .template import core_object_component_template, core_object_template
 from .transform import core_transform, core_transform_jinja2, core_transform_python
 from .webhook import core_custom_webhook, core_standard_webhook, core_webhook
 
-core_node = {
-    "name": "Node",
-    "namespace": "Core",
-    "include_in_menu": False,
-    "description": "Base Node in Infrahub.",
-    "label": "Node",
-}
-
-core_task_target = {
-    "name": "TaskTarget",
-    "include_in_menu": False,
-    "namespace": "Core",
-    "description": "Extend a node to be associated with tasks",
-    "label": "Task Target",
-}
-
-core_models: dict[str, Any] = {
+core_models_mixed: dict[str, list] = {
     "generics": [
         core_node,
         lineage_owner,
@@ -98,6 +85,7 @@ core_models: dict[str, Any] = {
         core_base_permission,
         core_credential,
         core_object_template,
+        core_object_component_template,
         generic_menu_item,
     ],
     "nodes": [
@@ -117,7 +105,7 @@ core_models: dict[str, Any] = {
         core_object_thread,
         core_change_comment,
         core_thread_comment,
-        core_repository.to_dict(),
+        core_repository,
         core_read_only_repository,
         core_transform_jinja2,
         core_data_check,
@@ -151,3 +139,9 @@ core_models: dict[str, Any] = {
         core_account_group,
     ],
 }
+
+
+core_models: dict[str, Any] = {
+    "generics": [item.to_dict() if isinstance(item, GenericSchema) else item for item in core_models_mixed["generics"]],
+    "nodes": [item.to_dict() if isinstance(item, NodeSchema) else item for item in core_models_mixed["nodes"]],
+}