infrahub-server 1.7.0rc0__py3-none-any.whl → 1.7.1__py3-none-any.whl

infrahub/core/schema/manager.py

@@ -25,6 +25,7 @@ from infrahub.core.schema import (
     SchemaRoot,
     TemplateSchema,
 )
+from infrahub.core.timestamp import Timestamp
 from infrahub.core.utils import parse_node_kind
 from infrahub.exceptions import SchemaNotFoundError
 from infrahub.log import get_logger
@@ -36,7 +37,6 @@ log = get_logger()
 
 if TYPE_CHECKING:
     from infrahub.core.branch import Branch
-    from infrahub.core.timestamp import Timestamp
     from infrahub.database import InfrahubDatabase
 
 
@@ -179,18 +179,20 @@ class SchemaManager(NodeManager):
         diff: SchemaDiff | None = None,
         limit: list[str] | None = None,
         update_db: bool = True,
+        at: Timestamp | None = None,
         user_id: str = SYSTEM_USER_ID,
     ) -> None:
         branch = await registry.get_branch(branch=branch, db=db)
+        at = Timestamp(at)
 
         updated_schema = None
         if update_db:
             if diff:
                 schema_diff = await self.update_schema_to_db(
-                    schema=schema, db=db, branch=branch, diff=diff, user_id=user_id
+                    schema=schema, db=db, branch=branch, diff=diff, at=at, user_id=user_id
                 )
             else:
-                await self.load_schema_to_db(schema=schema, db=db, branch=branch, limit=limit, user_id=user_id)
+                await self.load_schema_to_db(schema=schema, db=db, branch=branch, limit=limit, at=at, user_id=user_id)
                 # After updating the schema into the db
                 # we need to pull a fresh version because some default value are managed/generated within the node object
                 schema_diff = None
@@ -201,7 +203,7 @@ class SchemaManager(NodeManager):
                     )
 
             updated_schema = await self.load_schema_from_db(
-                db=db, branch=branch, schema=schema, schema_diff=schema_diff
+                db=db, branch=branch, schema=schema, schema_diff=schema_diff, at=at
             )
 
         self.set_schema_branch(name=branch.name, schema=updated_schema or schema)
@@ -221,6 +223,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         diff: SchemaDiff,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> SchemaBranchDiff:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
@@ -231,7 +234,7 @@ class SchemaManager(NodeManager):
         added_generics = []
         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, user_id=user_id)
+            node = await self.load_node_to_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
             schema.set(name=item_kind, schema=node)
             if item.is_node_schema:
                 added_nodes.append(item_kind)
@@ -244,10 +247,10 @@ class SchemaManager(NodeManager):
             item = schema.get(name=item_kind, duplicate=False)
             if item_diff:
                 node = await self.update_node_in_db_based_on_diff(
-                    node=item, branch=branch, db=db, diff=item_diff, user_id=user_id
+                    node=item, branch=branch, db=db, diff=item_diff, at=at, user_id=user_id
                 )
             else:
-                node = await self.update_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
+                node = await self.update_node_in_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
             schema.set(name=item_kind, schema=node)
             if item.is_node_schema:
                 changed_nodes.append(item_kind)
@@ -258,7 +261,7 @@ class SchemaManager(NodeManager):
         removed_generics = []
         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, user_id=user_id)
+            node = await self.delete_node_in_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
             schema.delete(name=item_kind)
             if item.is_node_schema:
                 removed_nodes.append(item_kind)
@@ -281,9 +284,10 @@ class SchemaManager(NodeManager):
         branch: Branch | str | None = None,
         limit: list[str] | None = None,
         user_id: str = SYSTEM_USER_ID,
+        at: Timestamp | None = None,
     ) -> None:
         """Load all nodes, generics and groups from a SchemaRoot object into the database."""
-
+        at = Timestamp(at)
         branch = await registry.get_branch(branch=branch, db=db)
 
         for item_kind in schema.node_names + schema.generic_names_without_templates:
@@ -291,10 +295,10 @@ class SchemaManager(NodeManager):
                 continue
             item = schema.get(name=item_kind, duplicate=False)
             if not item.id:
-                node = await self.load_node_to_db(node=item, branch=branch, db=db, user_id=user_id)
+                node = await self.load_node_to_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
                 schema.set(name=item_kind, schema=node)
             else:
-                node = await self.update_node_in_db(node=item, branch=branch, db=db, user_id=user_id)
+                node = await self.update_node_in_db(node=item, branch=branch, db=db, at=at, user_id=user_id)
                 schema.set(name=item_kind, schema=node)
 
     async def load_node_to_db(
@@ -302,6 +306,7 @@ class SchemaManager(NodeManager):
         node: NodeSchema | GenericSchema,
         db: InfrahubDatabase,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Load a Node with its attributes and its relationships to the database."""
@@ -322,7 +327,7 @@ class SchemaManager(NodeManager):
         schema_dict = node.model_dump(exclude={"id", "state", "filters", "relationships", "attributes"})
         obj = await Node.init(schema=node_schema, branch=branch, db=db)
         await obj.new(**schema_dict, db=db)
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
         new_node.id = obj.id
 
         # Then create the Attributes and the relationships
@@ -333,7 +338,7 @@ class SchemaManager(NodeManager):
             for item in node.attributes:
                 if item.inherited is False:
                     new_attr = await self.create_attribute_in_db(
-                        schema=attribute_schema, item=item, parent=obj, branch=branch, db=db, user_id=user_id
+                        schema=attribute_schema, item=item, parent=obj, branch=branch, db=db, at=at, user_id=user_id
                     )
                 else:
                     new_attr = item.duplicate()
@@ -342,7 +347,7 @@ class SchemaManager(NodeManager):
             for item in node.relationships:
                 if item.inherited is False:
                     new_rel = await self.create_relationship_in_db(
-                        schema=relationship_schema, item=item, parent=obj, branch=branch, db=db, user_id=user_id
+                        schema=relationship_schema, item=item, parent=obj, branch=branch, db=db, at=at, user_id=user_id
                     )
                 else:
                     new_rel = item.duplicate()
@@ -357,6 +362,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         node: NodeSchema | GenericSchema,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database."""
@@ -380,11 +386,11 @@ class SchemaManager(NodeManager):
         new_node = node.duplicate()
 
         # Update the attributes and the relationships nodes as well
-        await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id])
+        await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id], at=at)
         await obj.relationships.update(
-            db=db, data=[item.id for item in node.local_relationships if item.id and item.name != "profiles"]
+            db=db, data=[item.id for item in node.local_relationships if item.id and item.name != "profiles"], at=at
         )
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
 
         # Then Update the Attributes and the relationships
 
@@ -397,19 +403,19 @@ class SchemaManager(NodeManager):
 
         for item in node.local_attributes:
             if item.id and item.id in items:
-                await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, user_id=user_id)
+                await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, at=at, user_id=user_id)
             elif not item.id:
                 new_attr = await self.create_attribute_in_db(
-                    schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
+                    schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, at=at, user_id=user_id
                 )
                 new_node.attributes.append(new_attr)
 
         for item in node.local_relationships:
             if item.id and item.id in items:
-                await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, user_id=user_id)
+                await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, at=at, user_id=user_id)
             elif not item.id:
                 new_rel = await self.create_relationship_in_db(
-                    schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
+                    schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, at=at, user_id=user_id
                 )
                 new_node.relationships.append(new_rel)
 
@@ -423,6 +429,7 @@ class SchemaManager(NodeManager):
         diff: HashableModelDiff,
         node: NodeSchema | GenericSchema,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> NodeSchema | GenericSchema:
         """Update a Node with its attributes and its relationships in the database based on a HashableModelDiff."""
@@ -496,24 +503,24 @@ class SchemaManager(NodeManager):
             items.update({field.id: field for field in missing_attrs + missing_rels})
 
         if diff_attributes:
-            await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id])
+            await obj.attributes.update(db=db, data=[item.id for item in node.local_attributes if item.id], at=at)
 
         if diff_relationships:
-            await obj.relationships.update(db=db, data=[item.id for item in node.local_relationships if item.id])
+            await obj.relationships.update(db=db, data=[item.id for item in node.local_relationships if item.id], at=at)
 
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
 
         if diff_attributes:
             for item in node.local_attributes:
                 # if item is in changed and has no ID, then it is being overridden from a generic and must be added
                 if item.name in diff_attributes.added or (item.name in diff_attributes.changed and item.id is None):
                     created_item = await self.create_attribute_in_db(
-                        schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
+                        schema=attribute_schema, item=item, branch=branch, db=db, parent=obj, at=at, user_id=user_id
                     )
                     new_attr = new_node.get_attribute(name=item.name)
                     new_attr.id = created_item.id
                 elif item.name in diff_attributes.changed and item.id and item.id in items:
-                    await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, user_id=user_id)
+                    await self.update_attribute_in_db(item=item, attr=items[item.id], db=db, at=at, user_id=user_id)
                 elif item.name in diff_attributes.removed and item.id and item.id in items:
                     await items[item.id].delete(db=db, user_id=user_id)
                 elif (
@@ -530,12 +537,12 @@ class SchemaManager(NodeManager):
                     item.name in diff_relationships.changed and item.id is None
                 ):
                     created_rel = await self.create_relationship_in_db(
-                        schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, user_id=user_id
+                        schema=relationship_schema, item=item, branch=branch, db=db, parent=obj, at=at, user_id=user_id
                     )
                     new_rel = new_node.get_relationship(name=item.name)
                     new_rel.id = created_rel.id
                 elif item.name in diff_relationships.changed and item.id and item.id in items:
-                    await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, user_id=user_id)
+                    await self.update_relationship_in_db(item=item, rel=items[item.id], db=db, at=at, user_id=user_id)
                 elif item.name in diff_relationships.removed and item.id and item.id in items:
                     await items[item.id].delete(db=db, user_id=user_id)
                 elif (
@@ -555,7 +562,7 @@ class SchemaManager(NodeManager):
         if field_names_to_remove:
             for field_schema in items.values():
                 if field_schema.name.value in field_names_to_remove:
-                    await field_schema.delete(db=db, user_id=user_id)
+                    await field_schema.delete(db=db, at=at, user_id=user_id)
 
         # Save back the node with the (potentially) newly created IDs in the SchemaManager
         self.set(name=new_node.kind, schema=new_node, branch=branch.name)
@@ -566,6 +573,7 @@ class SchemaManager(NodeManager):
         db: InfrahubDatabase,
         node: NodeSchema | GenericSchema,
         user_id: str,
+        at: Timestamp,
         branch: Branch | str | None = None,
     ) -> None:
         """Delete the node with its attributes and relationships."""
@@ -581,11 +589,11 @@ class SchemaManager(NodeManager):
 
         # First delete the attributes and the relationships
         for attr_schema_node in (await obj.attributes.get_peers(db=db)).values():
-            await attr_schema_node.delete(db=db, user_id=user_id)
+            await attr_schema_node.delete(db=db, at=at, user_id=user_id)
         for rel_schema_node in (await obj.relationships.get_peers(db=db)).values():
-            await rel_schema_node.delete(db=db, user_id=user_id)
+            await rel_schema_node.delete(db=db, at=at, user_id=user_id)
 
-        await obj.delete(db=db, user_id=user_id)
+        await obj.delete(db=db, at=at, user_id=user_id)
 
     @staticmethod
     async def create_attribute_in_db(
@@ -595,20 +603,23 @@ class SchemaManager(NodeManager):
         parent: Node,
         db: InfrahubDatabase,
         user_id: str,
+        at: Timestamp,
     ) -> AttributeSchema:
         obj = await Node.init(schema=schema, branch=branch, db=db)
         await obj.new(**item.to_node(), node=parent, db=db)
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
         new_item = item.duplicate()
         new_item.id = obj.id
         return new_item
 
     @staticmethod
-    async def update_attribute_in_db(item: AttributeSchema, attr: Node, db: InfrahubDatabase, user_id: str) -> None:
+    async def update_attribute_in_db(
+        item: AttributeSchema, attr: Node, db: InfrahubDatabase, at: Timestamp, user_id: str
+    ) -> None:
         item_dict = item.model_dump(exclude={"id", "state", "filters"})
         for key, value in item_dict.items():
             getattr(attr, key).value = value
-        await attr.save(db=db, user_id=user_id)
+        await attr.save(db=db, at=at, user_id=user_id)
 
     @staticmethod
     async def create_relationship_in_db(
@@ -618,22 +629,23 @@ class SchemaManager(NodeManager):
         parent: Node,
         db: InfrahubDatabase,
         user_id: str,
+        at: Timestamp,
     ) -> RelationshipSchema:
         obj = await Node.init(schema=schema, branch=branch, db=db)
         await obj.new(**item.model_dump(exclude={"id", "state", "filters"}), node=parent, db=db)
-        await obj.save(db=db, user_id=user_id)
+        await obj.save(db=db, at=at, user_id=user_id)
         new_item = item.duplicate()
         new_item.id = obj.id
         return new_item
 
     @staticmethod
     async def update_relationship_in_db(
-        item: RelationshipSchema, rel: Node, db: InfrahubDatabase, user_id: str
+        item: RelationshipSchema, rel: Node, db: InfrahubDatabase, at: Timestamp, user_id: str
     ) -> None:
         item_dict = item.model_dump(exclude={"id", "state", "filters"})
         for key, value in item_dict.items():
             getattr(rel, key).value = value
-        await rel.save(db=db, user_id=user_id)
+        await rel.save(db=db, at=at, user_id=user_id)
 
     async def load_schema(
         self,

infrahub/core/validators/attribute/kind.py

@@ -36,7 +36,7 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         self.params["null_value"] = NULL_VALUE
 
         query = """
-        MATCH p = (n:%(node_kind)s)
+        MATCH (n:%(node_kinds)s)
         CALL (n) {
             MATCH path = (root:Root)<-[rr:IS_PART_OF]-(n)-[ra:HAS_ATTRIBUTE]-(:Attribute { name: $attr_name } )-[rv:HAS_VALUE]-(av:AttributeValue)
             WHERE all(
@@ -51,7 +51,10 @@ class AttributeKindUpdateValidatorQuery(AttributeSchemaValidatorQuery):
         WHERE all(r in relationships(full_path) WHERE r.status = "active")
         AND attribute_value IS NOT NULL
         AND attribute_value <> $null_value
-        """ % {"branch_filter": branch_filter, "node_kind": self.node_schema.kind}
+        """ % {
+            "branch_filter": branch_filter,
+            "node_kinds": f"{self.node_schema.kind}|Profile{self.node_schema.kind}|Template{self.node_schema.kind}",
+        }
 
         self.add_to_query(query)
         self.return_labels = ["node.uuid", "attribute_value", "value_relationship.branch as value_branch"]

infrahub/graphql/manager.py

@@ -598,7 +598,10 @@ class GraphQLSchemaManager:
                 required=False,
                 description="Human friendly identifier",
             ),
-            "_updated_at": graphene.DateTime(required=False),
+            "_updated_at": graphene.DateTime(
+                required=False,
+                deprecation_reason="Query the node_metadata field instead. Will be removed in Infrahub 1.9",
+            ),
             "display_label": graphene.String(required=False),
             "Meta": type("Meta", (object,), meta_attrs),
         }
@@ -1209,7 +1212,10 @@ class GraphQLSchemaManager:
 
         main_attrs: dict[str, Any] = {
             "node": graphene.Field(base_interface, required=False),
-            "_updated_at": graphene.DateTime(required=False),
+            "_updated_at": graphene.DateTime(
+                required=False,
+                deprecation_reason="Query the node_metadata field instead. Will be removed in Infrahub 1.9",
+            ),
             "node_metadata": graphene.Field(node_metadata, required=True),
             "Meta": type("Meta", (object,), meta_attrs),
         }

infrahub/lock.py

@@ -10,6 +10,7 @@ from typing import TYPE_CHECKING
 
 import redis.asyncio as redis
 from prometheus_client import Histogram
+from redis import UsernamePasswordCredentialProvider
 from redis.asyncio.lock import Lock as GlobalLock
 
 from infrahub import config
@@ -275,10 +276,16 @@ class InfrahubLockRegistry:
     ) -> None:
         if config.SETTINGS.cache.enable and not local_only:
             if config.SETTINGS.cache.driver == config.CacheDriver.Redis:
+                credential_provider: UsernamePasswordCredentialProvider | None = None
+                if config.SETTINGS.cache.username and config.SETTINGS.cache.password:
+                    credential_provider = UsernamePasswordCredentialProvider(
+                        username=config.SETTINGS.cache.username, password=config.SETTINGS.cache.password
+                    )
                 self.connection = redis.Redis(
                     host=config.SETTINGS.cache.address,
                     port=config.SETTINGS.cache.service_port,
                     db=config.SETTINGS.cache.database,
+                    credential_provider=credential_provider,
                     ssl=config.SETTINGS.cache.tls_enabled,
                     ssl_cert_reqs="optional" if not config.SETTINGS.cache.tls_insecure else "none",
                     ssl_check_hostname=not config.SETTINGS.cache.tls_insecure,

infrahub/services/adapters/cache/redis.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import redis.asyncio as redis
+from redis import UsernamePasswordCredentialProvider
 
 from infrahub import config
 from infrahub.services.adapters.cache import InfrahubCache
@@ -13,10 +14,16 @@ if TYPE_CHECKING:
 
 class RedisCache(InfrahubCache):
     def __init__(self) -> None:
+        credential_provider: UsernamePasswordCredentialProvider | None = None
+        if config.SETTINGS.cache.username and config.SETTINGS.cache.password:
+            credential_provider = UsernamePasswordCredentialProvider(
+                username=config.SETTINGS.cache.username, password=config.SETTINGS.cache.password
+            )
         self.connection = redis.Redis(
             host=config.SETTINGS.cache.address,
             port=config.SETTINGS.cache.service_port,
             db=config.SETTINGS.cache.database,
+            credential_provider=credential_provider,
             ssl=config.SETTINGS.cache.tls_enabled,
             ssl_cert_reqs="optional" if not config.SETTINGS.cache.tls_insecure else "none",
             ssl_check_hostname=not config.SETTINGS.cache.tls_insecure,

infrahub_sdk/analyzer.py

@@ -30,10 +30,10 @@ class GraphQLOperation(BaseModel):
 
 
 class GraphQLQueryAnalyzer:
-    def __init__(self, query: str, schema: GraphQLSchema | None = None) -> None:
+    def __init__(self, query: str, schema: GraphQLSchema | None = None, document: DocumentNode | None = None) -> None:
         self.query: str = query
         self.schema: GraphQLSchema | None = schema
-        self.document: DocumentNode = parse(self.query)
+        self.document: DocumentNode = document or parse(self.query)
         self._fields: dict | None = None
 
     @property

infrahub_sdk/branch.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import warnings
 from enum import Enum
 from typing import TYPE_CHECKING, Any, Literal, overload
 from urllib.parse import urlencode
@@ -93,7 +92,6 @@ class InfrahubBranchManager(InfraHubBranchManagerBase):
         sync_with_git: bool = True,
         description: str = "",
         wait_until_completion: Literal[True] = True,
-        background_execution: bool | None = False,
     ) -> BranchData: ...
 
     @overload
@@ -103,7 +101,6 @@ class InfrahubBranchManager(InfraHubBranchManagerBase):
         sync_with_git: bool = True,
         description: str = "",
         wait_until_completion: Literal[False] = False,
-        background_execution: bool | None = False,
     ) -> str: ...
 
     async def create(
@@ -112,19 +109,9 @@ class InfrahubBranchManager(InfraHubBranchManagerBase):
         sync_with_git: bool = True,
         description: str = "",
         wait_until_completion: bool = True,
-        background_execution: bool | None = False,
     ) -> BranchData | str:
-        if background_execution is not None:
-            warnings.warn(
-                "`background_execution` is deprecated, please use `wait_until_completion` instead.",
-                DeprecationWarning,
-                stacklevel=1,
-            )
-
-        background_execution = background_execution or not wait_until_completion
         input_data = {
-            # Should be switched to `wait_until_completion` once `background_execution` is removed server side.
-            "background_execution": background_execution,
+            "wait_until_completion": wait_until_completion,
             "data": {
                 "name": branch_name,
                 "description": description,
@@ -132,15 +119,14 @@ class InfrahubBranchManager(InfraHubBranchManagerBase):
             },
         }
 
-        mutation_query = MUTATION_QUERY_TASK if background_execution else MUTATION_QUERY_DATA
+        mutation_query = MUTATION_QUERY_DATA if wait_until_completion else MUTATION_QUERY_TASK
         query = Mutation(mutation="BranchCreate", input_data=input_data, query=mutation_query)
         response = await self.client.execute_graphql(query=query.render(), tracker="mutation-branch-create")
 
-        # Make sure server version is recent enough to support background execution, as previously
-        # using background_execution=True had no effect.
-        if background_execution and "task" in response["BranchCreate"]:
-            return response["BranchCreate"]["task"]["id"]
-        return BranchData(**response["BranchCreate"]["object"])
+        if wait_until_completion:
+            return BranchData(**response["BranchCreate"]["object"])
+
+        return response["BranchCreate"]["task"]["id"]
 
     async def delete(self, branch_name: str) -> bool:
         input_data = {
@@ -261,7 +247,6 @@ class InfrahubBranchManagerSync(InfraHubBranchManagerBase):
         sync_with_git: bool = True,
         description: str = "",
         wait_until_completion: Literal[True] = True,
-        background_execution: bool | None = False,
     ) -> BranchData: ...
 
     @overload
@@ -271,7 +256,6 @@ class InfrahubBranchManagerSync(InfraHubBranchManagerBase):
         sync_with_git: bool = True,
         description: str = "",
         wait_until_completion: Literal[False] = False,
-        background_execution: bool | None = False,
     ) -> str: ...
 
     def create(
@@ -280,19 +264,9 @@ class InfrahubBranchManagerSync(InfraHubBranchManagerBase):
         sync_with_git: bool = True,
         description: str = "",
         wait_until_completion: bool = True,
-        background_execution: bool | None = False,
     ) -> BranchData | str:
-        if background_execution is not None:
-            warnings.warn(
-                "`background_execution` is deprecated, please use `wait_until_completion` instead.",
-                DeprecationWarning,
-                stacklevel=1,
-            )
-
-        background_execution = background_execution or not wait_until_completion
         input_data = {
-            # Should be switched to `wait_until_completion` once `background_execution` is removed server side.
-            "background_execution": background_execution,
+            "wait_until_completion": wait_until_completion,
             "data": {
                 "name": branch_name,
                 "description": description,
@@ -300,15 +274,14 @@ class InfrahubBranchManagerSync(InfraHubBranchManagerBase):
             },
         }
 
-        mutation_query = MUTATION_QUERY_TASK if background_execution else MUTATION_QUERY_DATA
+        mutation_query = MUTATION_QUERY_DATA if wait_until_completion else MUTATION_QUERY_TASK
         query = Mutation(mutation="BranchCreate", input_data=input_data, query=mutation_query)
         response = self.client.execute_graphql(query=query.render(), tracker="mutation-branch-create")
 
-        # Make sure server version is recent enough to support background execution, as previously
-        # using background_execution=True had no effect.
-        if background_execution and "task" in response["BranchCreate"]:
-            return response["BranchCreate"]["task"]["id"]
-        return BranchData(**response["BranchCreate"]["object"])
+        if wait_until_completion:
+            return BranchData(**response["BranchCreate"]["object"])
+
+        return response["BranchCreate"]["task"]["id"]
 
     def delete(self, branch_name: str) -> bool:
         input_data = {

infrahub_sdk/checks.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
 
-import asyncio
 import importlib
-import os
+import inspect
+import pathlib
 import warnings
 from abc import abstractmethod
 from typing import TYPE_CHECKING, Any
@@ -55,7 +55,7 @@ class InfrahubCheck:
         self.branch = branch
         self.params = params or {}
 
-        self.root_directory = root_directory or os.getcwd()
+        self.root_directory = root_directory or str(pathlib.Path.cwd())
 
         self._client = client
 
@@ -160,7 +160,7 @@ class InfrahubCheck:
             data = await self.collect_data()
         unpacked = data.get("data") or data
 
-        if asyncio.iscoroutinefunction(self.validate):
+        if inspect.iscoroutinefunction(self.validate):
             await self.validate(data=unpacked)
         else:
             self.validate(data=unpacked)