infrahub-server 1.1.6__py3-none-any.whl → 1.2.0rc0__py3-none-any.whl

infrahub/core/schema/basenode_schema.py

@@ -22,13 +22,11 @@ if TYPE_CHECKING:
     from infrahub.core.schema import GenericSchema, NodeSchema
     from infrahub.core.schema.schema_branch import SchemaBranch
 
-# pylint: disable=redefined-builtin
-
 
 NODE_METADATA_ATTRIBUTES = ["_source", "_owner"]
 
 
-class BaseNodeSchema(GeneratedBaseNodeSchema):  # pylint: disable=too-many-public-methods
+class BaseNodeSchema(GeneratedBaseNodeSchema):
     _exclude_from_hash: list[str] = ["attributes", "relationships"]
     _sort_by: list[str] = ["namespace", "name"]
 

infrahub/core/schema/definitions/core.py

@@ -26,8 +26,6 @@ from infrahub.core.constants import (
 )
 from infrahub.proposed_change.constants import ProposedChangeState
 
-# pylint: disable=too-many-lines
-
 core_profile_schema_definition: dict[str, Any] = {
     "name": "Profile",
     "namespace": "Core",
@@ -969,6 +967,20 @@ core_models: dict[str, Any] = {
                 {"name": "description", "kind": "Text", "optional": True, "order_weight": 3000},
             ],
         },
+        {
+            "name": "ObjectTemplate",
+            "namespace": "Core",
+            "include_in_menu": False,
+            "icon": "mdi:pencil-ruler",
+            "description": "Template to create pre-shaped objects.",
+            "label": "Object Templates",
+            "display_labels": ["template_name__value"],
+            "default_filter": "template_name__value",
+            "uniqueness_constraints": [["template_name__value"]],
+            "attributes": [
+                {"name": "template_name", "kind": "Text", "optional": False, "unique": True, "order_weight": 1000}
+            ],
+        },
         generic_menu_item,
     ],
     "nodes": [

infrahub/core/schema/definitions/internal.py

@@ -394,6 +394,14 @@ node_schema = SchemaNode(
             optional=True,
             extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
         ),
+        SchemaAttribute(
+            name="generate_template",
+            kind="Boolean",
+            description="Indicate if an object template schema should be generated for this schema",
+            default_value=False,
+            optional=True,
+            extra={"update": UpdateSupport.ALLOWED},
+        ),
         SchemaAttribute(
             name="hierarchy",
             kind="Text",
@@ -858,6 +866,14 @@ generic_schema = SchemaNode(
             optional=True,
             extra={"update": UpdateSupport.VALIDATE_CONSTRAINT},
         ),
+        SchemaAttribute(
+            name="generate_template",
+            kind="Boolean",
+            description="Indicate if an object template schema should be generated for this schema",
+            default_value=False,
+            optional=True,
+            extra={"update": UpdateSupport.ALLOWED},
+        ),
         SchemaAttribute(
             name="used_by",
             kind="List",

infrahub/core/schema/generated/genericnode_schema.py

@@ -18,6 +18,11 @@ class GeneratedGenericSchema(BaseNodeSchema):
         description="Indicate if a profile schema should be generated for this schema",
         json_schema_extra={"update": "validate_constraint"},
     )
+    generate_template: bool = Field(
+        default=False,
+        description="Indicate if an object template schema should be generated for this schema",
+        json_schema_extra={"update": "allowed"},
+    )
     used_by: list[str] = Field(
         default_factory=list,
         description="List of Nodes that are referencing this Generic",

infrahub/core/schema/generated/node_schema.py

@@ -20,6 +20,11 @@ class GeneratedNodeSchema(BaseNodeSchema):
         description="Indicate if a profile schema should be generated for this schema",
         json_schema_extra={"update": "validate_constraint"},
     )
+    generate_template: bool = Field(
+        default=False,
+        description="Indicate if an object template schema should be generated for this schema",
+        json_schema_extra={"update": "allowed"},
+    )
     hierarchy: Optional[str] = Field(
         default=None,
         description="Internal value to track the name of the Hierarchy, must match the name of a Generic supporting hierarchical mode",

infrahub/core/schema/generic_schema.py

@@ -24,7 +24,11 @@ class GenericSchema(GeneratedGenericSchema):
     def is_profile_schema(self) -> bool:
         return False
 
-    def get_hierarchy_schema(self, db: InfrahubDatabase, branch: Optional[Union[Branch, str]] = None) -> GenericSchema:  # pylint: disable=unused-argument
+    @property
+    def is_template_schema(self) -> bool:
+        return False
+
+    def get_hierarchy_schema(self, db: InfrahubDatabase, branch: Optional[Union[Branch, str]] = None) -> GenericSchema:  # noqa: ARG002
         if self.hierarchical:
             return self
 

infrahub/core/schema/manager.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from infrahub import lock
 from infrahub.core.manager import NodeManager
@@ -19,6 +19,7 @@ from infrahub.core.schema import (
     ProfileSchema,
     RelationshipSchema,
     SchemaRoot,
+    TemplateSchema,
 )
 from infrahub.core.utils import parse_node_kind
 from infrahub.exceptions import SchemaNotFoundError
@@ -35,7 +36,6 @@ if TYPE_CHECKING:
     from infrahub.database import InfrahubDatabase
 
 
-# pylint: disable=too-many-public-methods
 class SchemaManager(NodeManager):
     def __init__(self) -> None:
         self._cache: dict[int, Any] = {}
@@ -44,7 +44,7 @@ class SchemaManager(NodeManager):
     def _get_from_cache(self, key: int) -> Any:
         return self._cache[key]
 
-    def set(self, name: str, schema: Union[NodeSchema, GenericSchema], branch: Optional[str] = None) -> int:
+    def set(self, name: str, schema: NodeSchema | GenericSchema, branch: str | None = None) -> int:
         branch = branch or registry.default_branch
 
         if branch not in self._branches:
@@ -54,7 +54,7 @@ class SchemaManager(NodeManager):
 
         return hash(self._branches[branch])
 
-    def has(self, name: str, branch: Optional[Union[Branch, str]] = None) -> bool:
+    def has(self, name: str, branch: Branch | str | None = None) -> bool:
         try:
             self.get(name=name, branch=branch, duplicate=False)
             return True
@@ -64,7 +64,7 @@ class SchemaManager(NodeManager):
     def get(
         self,
         name: str,
-        branch: Optional[Union[Branch, str]] = None,
+        branch: Branch | str | None = None,
         duplicate: bool = True,
         check_branch_only: bool = False,
     ) -> MainSchemaTypes:
@@ -86,9 +86,7 @@ class SchemaManager(NodeManager):
         default_branch = registry.default_branch
         return self._branches[default_branch].get(name=name, duplicate=duplicate)
 
-    def get_node_schema(
-        self, name: str, branch: Optional[Union[Branch, str]] = None, duplicate: bool = True
-    ) -> NodeSchema:
+    def get_node_schema(self, name: str, branch: Branch | str | None = None, duplicate: bool = True) -> NodeSchema:
         schema = self.get(name=name, branch=branch, duplicate=duplicate)
         if isinstance(schema, NodeSchema):
             return schema
@@ -96,7 +94,7 @@ class SchemaManager(NodeManager):
         raise ValueError("The selected node is not of type NodeSchema")
 
     def get_profile_schema(
-        self, name: str, branch: Optional[Union[Branch, str]] = None, duplicate: bool = True
+        self, name: str, branch: Branch | str | None = None, duplicate: bool = True
     ) -> ProfileSchema:
         schema = self.get(name=name, branch=branch, duplicate=duplicate)
         if isinstance(schema, ProfileSchema):
@@ -104,9 +102,16 @@ class SchemaManager(NodeManager):
 
         raise ValueError("The selected node is not of type ProfileSchema")
 
-    def get_full(
-        self, branch: Optional[Union[Branch, str]] = None, duplicate: bool = True
-    ) -> dict[str, MainSchemaTypes]:
+    def get_template_schema(
+        self, name: str, branch: Branch | str | None = None, duplicate: bool = True
+    ) -> TemplateSchema:
+        schema = self.get(name=name, branch=branch, duplicate=duplicate)
+        if isinstance(schema, TemplateSchema):
+            return schema
+
+        raise ValueError("The selected node is not of type TemplateSchema")
+
+    def get_full(self, branch: Branch | str | None = None, duplicate: bool = True) -> dict[str, MainSchemaTypes]:
         branch = registry.get_branch_from_registry(branch=branch)
 
         branch_name = None
@@ -117,9 +122,7 @@ class SchemaManager(NodeManager):
 
         return self._branches[branch_name].get_all(duplicate=duplicate)
 
-    async def get_full_safe(
-        self, branch: Optional[Union[Branch, str]] = None
-    ) -> dict[str, Union[NodeSchema, GenericSchema]]:
+    async def get_full_safe(self, branch: Branch | str | None = None) -> dict[str, NodeSchema | GenericSchema]:
         await lock.registry.local_schema_wait()
 
         return self.get_full(branch=branch)
@@ -143,9 +146,9 @@ class SchemaManager(NodeManager):
         self,
         schema: SchemaBranch,
         db: InfrahubDatabase,
-        branch: Optional[Union[Branch, str]] = None,
-        diff: Optional[SchemaDiff] = None,
-        limit: Optional[list[str]] = None,
+        branch: Branch | str | None = None,
+        diff: SchemaDiff | None = None,
+        limit: list[str] | None = None,
         update_db: bool = True,
     ) -> None:
         branch = await registry.get_branch(branch=branch, db=db)
@@ -172,7 +175,7 @@ class SchemaManager(NodeManager):
 
         self.set_schema_branch(name=branch.name, schema=updated_schema or schema)
 
-    def register_schema(self, schema: SchemaRoot, branch: Optional[str] = None) -> SchemaBranch:
+    def register_schema(self, schema: SchemaRoot, branch: str | None = None) -> SchemaBranch:
         """Register all nodes, generics & groups from a SchemaRoot object into the registry."""
 
         branch = branch or registry.default_branch
@@ -186,7 +189,7 @@ class SchemaManager(NodeManager):
         schema: SchemaBranch,
         db: InfrahubDatabase,
         diff: SchemaDiff,
-        branch: Optional[Union[str, Branch]] = None,
+        branch: Branch | str | None = None,
     ) -> SchemaBranchDiff:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
 
@@ -194,7 +197,7 @@ class SchemaManager(NodeManager):
 
         added_nodes = []
         added_generics = []
-        for item_kind, item_diff in diff.added.items():
+        for item_kind in diff.added.keys():
             item = schema.get(name=item_kind, duplicate=False)
             node = await self.load_node_to_db(node=item, branch=branch, db=db)
             schema.set(name=item_kind, schema=node)
@@ -219,7 +222,7 @@ class SchemaManager(NodeManager):
 
         removed_nodes = []
         removed_generics = []
-        for item_kind, item_diff in diff.removed.items():
+        for item_kind in diff.removed.keys():
             item = schema.get(name=item_kind, duplicate=False)
             node = await self.delete_node_in_db(node=item, branch=branch, db=db)
             schema.delete(name=item_kind)
@@ -241,8 +244,8 @@ class SchemaManager(NodeManager):
         self,
         schema: SchemaBranch,
         db: InfrahubDatabase,
-        branch: Optional[Union[str, Branch]] = None,
-        limit: Optional[list[str]] = None,
+        branch: Branch | str | None = None,
+        limit: list[str] | None = None,
     ) -> None:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
 
@@ -261,10 +264,10 @@ class SchemaManager(NodeManager):
 
     async def load_node_to_db(
         self,
-        node: Union[NodeSchema, GenericSchema],
+        node: NodeSchema | GenericSchema,
         db: InfrahubDatabase,
-        branch: Optional[Union[str, Branch]] = None,
-    ) -> Union[NodeSchema, GenericSchema]:
+        branch: Branch | str | None = None,
+    ) -> NodeSchema | GenericSchema:
         """Load a Node with its attributes and its relationships to the database."""
         branch = await registry.get_branch(branch=branch, db=db)
 
@@ -287,7 +290,7 @@ class SchemaManager(NodeManager):
         new_node.id = obj.id
 
         # Then create the Attributes and the relationships
-        if isinstance(node, (NodeSchema, GenericSchema)):
+        if isinstance(node, NodeSchema | GenericSchema):
             new_node.relationships = []
             new_node.attributes = []
 
@@ -310,9 +313,9 @@ class SchemaManager(NodeManager):
     async def update_node_in_db(
         self,
         db: InfrahubDatabase,
-        node: Union[NodeSchema, GenericSchema],
-        branch: Optional[Union[str, Branch]] = None,
-    ) -> Union[NodeSchema, GenericSchema]:
+        node: NodeSchema | GenericSchema,
+        branch: Branch | str | None = None,
+    ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database."""
         branch = await registry.get_branch(branch=branch, db=db)
 
@@ -372,13 +375,13 @@ class SchemaManager(NodeManager):
         self.set(name=new_node.kind, schema=new_node, branch=branch.name)
         return new_node
 
-    async def update_node_in_db_based_on_diff(  # pylint: disable=too-many-branches,too-many-statements
+    async def update_node_in_db_based_on_diff(
         self,
         db: InfrahubDatabase,
         diff: HashableModelDiff,
-        node: Union[NodeSchema, GenericSchema],
-        branch: Optional[Union[str, Branch]] = None,
-    ) -> Union[NodeSchema, GenericSchema]:
+        node: NodeSchema | GenericSchema,
+        branch: Branch | str | None = None,
+    ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database based on a HashableModelDiff."""
         branch = await registry.get_branch(branch=branch, db=db)
 
@@ -517,8 +520,8 @@ class SchemaManager(NodeManager):
     async def delete_node_in_db(
         self,
         db: InfrahubDatabase,
-        node: Union[NodeSchema, GenericSchema],
-        branch: Optional[Union[str, Branch]] = None,
+        node: NodeSchema | GenericSchema,
+        branch: Branch | str | None = None,
     ) -> None:
         """Delete the node with its attributes and relationships."""
         branch = await registry.get_branch(branch=branch, db=db)
@@ -584,7 +587,7 @@ class SchemaManager(NodeManager):
     async def load_schema(
         self,
         db: InfrahubDatabase,
-        branch: Optional[Union[str, Branch]] = None,
+        branch: Branch | str | None = None,
     ) -> SchemaBranch:
         """Load the schema either from the cache or from the database"""
         branch = await registry.get_branch(branch=branch, db=db)
@@ -610,10 +613,10 @@ class SchemaManager(NodeManager):
     async def load_schema_from_db(
         self,
         db: InfrahubDatabase,
-        branch: Optional[Union[str, Branch]] = None,
-        schema: Optional[SchemaBranch] = None,
-        schema_diff: Optional[SchemaBranchDiff] = None,
-        at: Optional[Timestamp] = None,
+        branch: Branch | str | None = None,
+        schema: SchemaBranch | None = None,
+        schema_diff: SchemaBranchDiff | None = None,
+        at: Timestamp | None = None,
         validate_schema: bool = True,
     ) -> SchemaBranch:
         """Query all the node of type NodeSchema and GenericSchema from the database and convert them to their respective type.

infrahub/core/schema/node_schema.py

@@ -25,6 +25,10 @@ class NodeSchema(GeneratedNodeSchema):
     def is_profile_schema(self) -> bool:
         return False
 
+    @property
+    def is_template_schema(self) -> bool:
+        return False
+
     def validate_inheritance(self, interface: GenericSchema) -> None:
         """Perform checks specific to inheritance from Generics.
 

infrahub/core/schema/profile_schema.py

@@ -24,6 +24,10 @@ class ProfileSchema(BaseNodeSchema):
     def is_profile_schema(self) -> bool:
         return True
 
+    @property
+    def is_template_schema(self) -> bool:
+        return False
+
     def get_labels(self) -> list[str]:
         """Return the labels for this object, composed of the kind
         and the list of Generic this object is inheriting from."""

infrahub/core/schema/relationship_schema.py

@@ -72,12 +72,12 @@ class RelationshipSchema(GeneratedRelationshipSchema):
         db: InfrahubDatabase,
         filter_name: str,
         filter_value: Optional[Union[str, int, bool]] = None,
-        name: Optional[str] = None,  # pylint: disable=unused-argument
+        name: Optional[str] = None,  # noqa: ARG002
         branch: Optional[Branch] = None,
         include_match: bool = True,
         param_prefix: Optional[str] = None,
         partial_match: bool = False,
-        support_profiles: bool = False,  # pylint: disable=unused-argument
+        support_profiles: bool = False,  # noqa: ARG002
     ) -> tuple[list[QueryElement], dict[str, Any], list[str]]:
         """Generate Query String Snippet to filter the right node."""