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

infrahub/graphql/types/branch.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Any
 
-from graphene import Boolean, Field, Int, String
+from graphene import Boolean, Field, Int, List, NonNull, String
 
 from infrahub.core.branch import Branch
 from infrahub.core.constants import GLOBAL_BRANCH_NAME
 
+from ...exceptions import BranchNotFoundError
 from .enums import InfrahubBranchStatus
 from .standard_node import InfrahubObjectType
 
@@ -33,6 +34,10 @@ class BranchType(InfrahubObjectType):
         name = "Branch"
         model = Branch
 
+    @staticmethod
+    async def _map_fields_to_graphql(objs: list[Branch], fields: dict) -> list[dict[str, Any]]:
+        return [await obj.to_graphql(fields=fields) for obj in objs]
+
     @classmethod
     async def get_list(
         cls,
@@ -46,4 +51,95 @@ class BranchType(InfrahubObjectType):
             if not objs:
                 return []
 
-            return [await obj.to_graphql(fields=fields) for obj in objs if obj.name != GLOBAL_BRANCH_NAME]
+            return await cls._map_fields_to_graphql(objs=objs, fields=fields)
+
+    @classmethod
+    async def get_by_name(
+        cls,
+        fields: dict,
+        graphql_context: GraphqlContext,
+        name: str,
+    ) -> dict[str, Any]:
+        branch_responses = await cls.get_list(fields=fields, graphql_context=graphql_context, name=name)
+
+        if branch_responses:
+            return branch_responses[0]
+        raise BranchNotFoundError(f"Branch with name '{name}' not found")
+
+
+class RequiredStringValueField(InfrahubObjectType):
+    value = String(required=True)
+
+
+class NonRequiredStringValueField(InfrahubObjectType):
+    value = String(required=False)
+
+
+class NonRequiredIntValueField(InfrahubObjectType):
+    value = Int(required=False)
+
+
+class NonRequiredBooleanValueField(InfrahubObjectType):
+    value = Boolean(required=False)
+
+
+class StatusField(InfrahubObjectType):
+    value = InfrahubBranchStatus(required=True)
+
+
+class InfrahubBranch(BranchType):
+    name = Field(RequiredStringValueField, required=True)
+    description = Field(NonRequiredStringValueField, required=False)
+    origin_branch = Field(NonRequiredStringValueField, required=False)
+    branched_from = Field(NonRequiredStringValueField, required=False)
+    graph_version = Field(NonRequiredIntValueField, required=False)
+    status = Field(StatusField, required=True)
+    sync_with_git = Field(NonRequiredBooleanValueField, required=False)
+    is_default = Field(NonRequiredBooleanValueField, required=False)
+    is_isolated = Field(
+        NonRequiredBooleanValueField, required=False, deprecation_reason="non isolated mode is not supported anymore"
+    )
+    has_schema_changes = Field(NonRequiredBooleanValueField, required=False)
+
+    class Meta:
+        description = "InfrahubBranch"
+        name = "InfrahubBranch"
+
+    @staticmethod
+    async def _map_fields_to_graphql(objs: list[Branch], fields: dict) -> list[dict[str, Any]]:
+        field_keys = fields.keys()
+        result: list[dict[str, Any]] = []
+        for obj in objs:
+            if obj.name == GLOBAL_BRANCH_NAME:
+                continue
+            data: dict[str, Any] = {}
+            for field in field_keys:
+                if field == "id":
+                    data["id"] = obj.uuid
+                    continue
+                value = getattr(obj, field, None)
+                if isinstance(fields.get(field), dict):
+                    data[field] = {"value": value}
+                else:
+                    data[field] = value
+            result.append(data)
+        return result
+
+
+class InfrahubBranchEdge(InfrahubObjectType):
+    node = Field(InfrahubBranch, required=True)
+
+
+class InfrahubBranchType(InfrahubObjectType):
+    count = Field(Int, description="Total number of items")
+    edges = Field(NonNull(List(of_type=NonNull(InfrahubBranchEdge))))
+    default_branch = Field(
+        InfrahubBranch,
+        required=True,
+        description="The default branch of the Infrahub instance, provides a direct way to access the default branch regardless of filters.",
+    )
+
+    @classmethod
+    async def get_list_count(cls, graphql_context: GraphqlContext, **kwargs: Any) -> int:
+        async with graphql_context.db.start_session(read_only=True) as db:
+            return await Branch.get_list_count(db=db, **kwargs)

infrahub/lock.py

@@ -58,7 +58,7 @@ class InfrahubMultiLock:
         self.locks = locks or []
         self.metrics = metrics
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> None:
         await self.acquire()
 
     async def __aexit__(
@@ -66,7 +66,7 @@ class InfrahubMultiLock:
         exc_type: type[BaseException] | None,
         exc_value: BaseException | None,
         traceback: TracebackType | None,
-    ):
+    ) -> None:
         await self.release()
 
     async def acquire(self) -> None:
@@ -86,7 +86,7 @@ class NATSLock:
         self.token = None
         self.service = service
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> None:
         await self.acquire()
 
     async def __aexit__(
@@ -94,7 +94,7 @@ class NATSLock:
         exc_type: type[BaseException] | None,
         exc_value: BaseException | None,
         traceback: TracebackType | None,
-    ):
+    ) -> None:
         await self.release()
 
     async def acquire(self) -> None:
@@ -162,7 +162,7 @@ class InfrahubLock:
     def acquire_time(self, value: int) -> None:
         self._acquire_time = value
 
-    async def __aenter__(self):
+    async def __aenter__(self) -> None:
         await self.acquire()
 
     async def __aexit__(
@@ -170,7 +170,7 @@ class InfrahubLock:
         exc_type: type[BaseException] | None,
         exc_value: BaseException | None,
         traceback: TracebackType | None,
-    ):
+    ) -> None:
         await self.release()
 
     async def acquire(self) -> None:

infrahub/log.py

@@ -10,7 +10,7 @@ from structlog.dev import plain_traceback
 if TYPE_CHECKING:
     from structlog.types import Processor
 
-INFRAHUB_PRODUCTION = TypeAdapter(bool).validate_python(os.environ.get("INFRAHUB_PRODUCTION", True))
+INFRAHUB_PRODUCTION = TypeAdapter(bool).validate_python(os.environ.get("INFRAHUB_PRODUCTION", "true"))
 INFRAHUB_LOG_LEVEL = os.environ.get("INFRAHUB_LOG_LEVEL", "INFO")
 
 

infrahub/message_bus/messages/__init__.py

@@ -22,20 +22,8 @@ RESPONSE_MAP: dict[str, type[InfrahubResponse]] = {
 }
 
 PRIORITY_MAP = {
-    "check.artifact.create": 2,
-    "check.repository.check_definition": 2,
-    "check.repository.merge_conflicts": 2,
     "send.echo.request": 5,  # Currently only for testing purposes, will be removed once all message bus have been migrated to prefect
-    "event.branch.delete": 5,
-    "event.branch.merge": 5,
-    "event.schema.update": 5,
-    "git.diff.names_only": 4,
     "git.file.get": 4,
-    "request.artifact.generate": 2,
-    "request.git.sync": 4,
-    "request.proposed_change.pipeline": 5,
-    "transform.jinja.template": 4,
-    "transform.python.data": 4,
 }
 
 

infrahub/patch/constants.py

@@ -1,7 +1,7 @@
-from enum import Enum
+from enum import StrEnum
 
 
-class PatchPlanFilename(str, Enum):
+class PatchPlanFilename(StrEnum):
     VERTICES_TO_ADD = "vertices_to_add.json"
     VERTICES_TO_UPDATE = "vertices_to_update.json"
     VERTICES_TO_DELETE = "vertices_to_delete.json"

infrahub/profiles/node_applier.py

@@ -9,6 +9,15 @@ from .queries.get_profile_data import GetProfileDataQuery, ProfileData
 
 
 class NodeProfilesApplier:
+    """Applies profile values to nodes and templates.
+
+    Profile values take precedence over both default values and template-sourced values.
+    When a template has profiles assigned:
+    1. Profile values are applied to the template itself
+    2. Nodes created from that template inherit the profile values (not the template's own values)
+    3. Profile priority determines which profile wins when multiple profiles set the same attribute
+    """
+
     def __init__(self, db: InfrahubDatabase, branch: Branch):
         self.db = db
         self.branch = branch

infrahub/proposed_change/tasks.py

@@ -480,7 +480,7 @@ async def _get_proposed_change_schema_integrity_constraints(
                 DiffElementType.RELATIONSHIP_ONE.value.lower(),
             ):
                 field_summary.relationship_names.add(element_name)
-            elif element_type.lower() in (DiffElementType.ATTRIBUTE.value.lower(),):
+            elif element_type.lower() == DiffElementType.ATTRIBUTE.value.lower():
                 field_summary.attribute_names.add(element_name)
 
     determiner = ConstraintValidatorDeterminer(schema_branch=schema)

infrahub/task_manager/task.py

@@ -1,7 +1,7 @@
 import asyncio
 import hashlib
 import json
-from datetime import datetime, timedelta, timezone
+from datetime import UTC, datetime, timedelta
 from typing import Any
 from uuid import UUID
 
@@ -151,7 +151,7 @@ class PrefectTask:
             remaining -= nb_fetched
 
         for flow_log in all_logs:
-            if flow_log.flow_run_id and flow_log.message not in ["Finished in state Completed()"]:
+            if flow_log.flow_run_id and flow_log.message != "Finished in state Completed()":
                 logs_flow.logs[flow_log.flow_run_id].append(flow_log)
 
         return logs_flow
@@ -325,7 +325,7 @@ class PrefectTask:
                                 "parameters": flow.parameters,
                                 "branch": await cls._extract_branch_name(flow=flow),
                                 "tags": flow.tags,
-                                "workflow": workflow_names.get(flow.flow_id, None),
+                                "workflow": workflow_names.get(flow.flow_id),
                                 "related_node": related_node.id if related_node else None,
                                 "related_node_kind": related_node.kind if related_node else None,
                                 "related_nodes": related_nodes_info.get_related_nodes_as_dict(flow_id=flow.id),
@@ -353,7 +353,7 @@ class PrefectTask:
         logger = get_logger()
 
         async with get_client(sync_client=False) as client:
-            cutoff = datetime.now(timezone.utc) - timedelta(days=days_to_keep)
+            cutoff = datetime.now(UTC) - timedelta(days=days_to_keep)
 
             flow_run_filter = FlowRunFilter(
                 start_time=FlowRunFilterStartTime(before_=cutoff),  # type: ignore[arg-type]

infrahub/telemetry/constants.py

@@ -1,9 +1,9 @@
-from enum import Enum
+from enum import StrEnum
 
 TELEMETRY_KIND: str = "community"
 TELEMETRY_VERSION: str = "20250318"
 
 
-class InfrahubType(str, Enum):
+class InfrahubType(StrEnum):
     COMMUNITY = "community"
     ENTERPRISE = "enterprise"

infrahub/trigger/models.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from datetime import timedelta
-from enum import Enum, StrEnum
+from enum import StrEnum
 from typing import TYPE_CHECKING, Any, TypeVar
 
 from prefect.events.actions import RunDeployment
@@ -92,7 +92,7 @@ class TriggerSetupReport(BaseModel):
         return created + updated
 
 
-class TriggerType(str, Enum):
+class TriggerType(StrEnum):
     ACTION_TRIGGER_RULE = "action_trigger_rule"
     BUILTIN = "builtin"
     WEBHOOK = "webhook"

infrahub/trigger/setup.py

@@ -122,7 +122,7 @@ async def setup_triggers(
             actions=[action.get_prefect(mapping=deployments_mapping) for action in trigger.actions],
         )
 
-        existing_automation = existing_automations.get(trigger.generate_name(), None)
+        existing_automation = existing_automations.get(trigger.generate_name())
 
         if existing_automation:
             trigger_comparison = compare_automations(
@@ -171,19 +171,16 @@ async def gather_all_automations(client: PrefectClient) -> list[Automation]:
     retrieves them all by paginating through the results. The default within Prefect is 200 items,
     and client.read_automations() doesn't support pagination parameters.
     """
-    automation_count_response = await client.request("POST", "/automations/count")
-    automation_count_response.raise_for_status()
-    automation_count: int = automation_count_response.json()
     offset = 0
     limit = 200
-    missing_automations = True
     automations: list[Automation] = []
-    while missing_automations:
+    while True:
         response = await client.request("POST", "/automations/filter", json={"limit": limit, "offset": offset})
         response.raise_for_status()
-        automations.extend(Automation.model_validate_list(response.json()))
-        if len(automations) >= automation_count:
-            missing_automations = False
+        batch = Automation.model_validate_list(response.json())
+        automations.extend(batch)
+        if len(batch) < limit:
+            break
         offset += limit
 
     return automations

infrahub/utils.py

@@ -76,10 +76,28 @@ def get_nested_dict(nested_dict: dict[str, Any], keys: list[str]) -> dict[str, A
     return current_level if isinstance(current_level, dict) else {}
 
 
-def get_all_subclasses(cls: AnyClass) -> list[AnyClass]:
+def get_all_subclasses[AnyClass: type](cls: AnyClass) -> list[AnyClass]:
     """Recursively get all subclasses of the given class."""
     subclasses: list[AnyClass] = []
     for subclass in cls.__subclasses__():
         subclasses.append(subclass)
         subclasses.extend(get_all_subclasses(subclass))
     return subclasses
+
+
+def has_any_key(data: dict[str, Any], keys: list[str]) -> bool:
+    """Recursively check if any of the specified keys exist in the dictionary at any level.
+
+    Args:
+        data: The dictionary to search through
+        keys: List of key names to search for
+
+    Returns:
+        True if any of the keys are found at any level of the dictionary, False otherwise
+    """
+    for key, value in data.items():
+        if key in keys:
+            return True
+        if isinstance(value, dict) and has_any_key(data=value, keys=keys):
+            return True
+    return False

infrahub/validators/tasks.py

@@ -12,7 +12,7 @@ from .events import send_start_validator
 ValidatorType = TypeVar("ValidatorType", bound=CoreValidator)
 
 
-async def start_validator(
+async def start_validator[ValidatorType: CoreValidator](
     client: InfrahubClient,
     validator: CoreValidator | None,
     validator_type: type[ValidatorType],

infrahub/workers/infrahub_async.py

@@ -1,5 +1,8 @@
+import asyncio
+import contextlib
 import logging
 import os
+from pathlib import Path
 from typing import Any
 
 import typer
@@ -105,7 +108,7 @@ class InfrahubWorkerAsync(BaseWorker):
 
         # Start metric endpoint
         if metric_port is None or metric_port != 0:
-            metric_port = metric_port or int(os.environ.get("INFRAHUB_METRICS_PORT", 8000))
+            metric_port = metric_port or int(os.environ.get("INFRAHUB_METRICS_PORT", "8000"))
             self._logger.info(f"Starting metric endpoint on port {metric_port}")
             start_http_server(metric_port)
 
@@ -122,6 +125,7 @@ class InfrahubWorkerAsync(BaseWorker):
         )
 
         set_component_type(component_type=self.component_type)
+        await self.set_git_global_config()
         await self._init_services(client=client)
 
         if not registry.schema_has_been_initialized():
@@ -204,3 +208,37 @@ class InfrahubWorkerAsync(BaseWorker):
         )
 
         self.service = service
+
+    async def set_git_global_config(self) -> None:
+        global_config_file = config.SETTINGS.git.global_config_file
+        if not os.getenv("GIT_CONFIG_GLOBAL") and global_config_file:
+            config_dir = Path(global_config_file).parent
+            with contextlib.suppress(FileExistsError):
+                config_dir.mkdir(exist_ok=True, parents=True)
+            os.environ["GIT_CONFIG_GLOBAL"] = global_config_file
+            self._logger.info(f"Set git config file to {global_config_file}")
+
+        await self._run_git_config_global(config.SETTINGS.git.user_name, setting_name="user.name")
+        await self._run_git_config_global(config.SETTINGS.git.user_email, setting_name="user.email")
+        await self._run_git_config_global("*", "--replace-all", setting_name="safe.directory")
+        await self._run_git_config_global("true", setting_name="credential.usehttppath")
+        await self._run_git_config_global(
+            f"/usr/bin/env {config.SETTINGS.dev.git_credential_helper}", setting_name="credential.helper"
+        )
+
+    async def _run_git_config_global(self, *args: str, setting_name: str) -> None:
+        proc = await asyncio.create_subprocess_exec(
+            "git",
+            "config",
+            "--global",
+            setting_name,
+            *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        _, stderr = await proc.communicate()
+        if proc.returncode != 0:
+            error_msg = stderr.decode("utf-8", errors="ignore").strip() or "unknown error"
+            self._logger.error(f"Failed to set git {setting_name}: %s", error_msg)
+        else:
+            self._logger.info(f"Git {setting_name} set")

infrahub_sdk/async_typer.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import asyncio
 import inspect
+from collections.abc import Callable
 from functools import partial, wraps
-from typing import Any, Callable
+from typing import Any
 
 from typer import Typer
 

infrahub_sdk/batch.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
 import asyncio
-from collections.abc import AsyncGenerator, Awaitable, Generator
+from collections.abc import AsyncGenerator, Awaitable, Callable, Generator
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Callable
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from .node import InfrahubNode, InfrahubNodeSync