infrahub-server 1.6.0b0__py3-none-any.whl → 1.6.1__py3-none-any.whl

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/branch_diff.py

@@ -64,4 +64,4 @@ async def get_diff_summary_cache(pipeline_id: UUID) -> list[NodeDiff]:
     if not summary_payload:
         raise ResourceNotFoundError(message=f"Diff summary for pipeline {pipeline_id} was not found in the cache")
 
-    return cast(list["NodeDiff"], json.loads(summary_payload))
+    return cast("list[NodeDiff]", json.loads(summary_payload))

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/repositories/create_repository.py

@@ -4,7 +4,6 @@ from typing import TYPE_CHECKING, cast
 
 from infrahub.core.constants import RepositoryInternalStatus
 from infrahub.core.constants.infrahubkind import READONLYREPOSITORY, REPOSITORY
-from infrahub.core.protocols import CoreGenericRepository, CoreReadOnlyRepository, CoreRepository
 from infrahub.exceptions import ValidationError
 from infrahub.git.models import GitRepositoryAdd, GitRepositoryAddReadOnly
 from infrahub.log import get_logger
@@ -16,6 +15,7 @@ if TYPE_CHECKING:
     from infrahub.auth import AccountSession
     from infrahub.context import InfrahubContext
     from infrahub.core.branch import Branch
+    from infrahub.core.protocols import CoreGenericRepository, CoreReadOnlyRepository, CoreRepository
     from infrahub.database import InfrahubDatabase
     from infrahub.services import InfrahubServices
 
@@ -74,7 +74,7 @@ class RepositoryFinalizer:
             authenticated_user = self.account_session.account_id
 
         if obj.get_kind() == READONLYREPOSITORY:
-            obj = cast(CoreReadOnlyRepository, obj)
+            obj = cast("CoreReadOnlyRepository", obj)
             model = GitRepositoryAddReadOnly(
                 repository_id=obj.id,
                 repository_name=obj.name.value,
@@ -92,7 +92,7 @@ class RepositoryFinalizer:
             )
 
         elif obj.get_kind() == REPOSITORY:
-            obj = cast(CoreRepository, obj)
+            obj = cast("CoreRepository", obj)
             git_repo_add_model = GitRepositoryAdd(
                 repository_id=obj.id,
                 repository_name=obj.name.value,

infrahub/task_manager/models.py

@@ -74,7 +74,7 @@ class FlowLogs(BaseModel):
                 "node": {
                     "message": log.message,
                     "severity": LOG_LEVEL_MAPPING.get(log.level, "error"),
-                    "timestamp": log.timestamp.to_iso8601_string(),
+                    "timestamp": log.timestamp.isoformat(),
                 }
             }
             for log in self.logs[flow_id]

infrahub/task_manager/task.py

@@ -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,13 +325,13 @@ 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),
-                                "created_at": flow.created.to_iso8601_string(),  # type: ignore
-                                "updated_at": flow.updated.to_iso8601_string(),  # type: ignore
-                                "start_time": flow.start_time.to_iso8601_string() if flow.start_time else None,
+                                "created_at": flow.created.isoformat() if flow.created else None,
+                                "updated_at": flow.updated.isoformat() if flow.updated else None,
+                                "start_time": flow.start_time.isoformat() if flow.start_time else None,
                                 "id": flow.id,
                                 "logs": {"edges": logs, "count": len(logs)},
                             }

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

@@ -83,3 +83,21 @@ def get_all_subclasses[AnyClass: type](cls: AnyClass) -> list[AnyClass]:
         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

@@ -26,7 +26,7 @@ async def start_validator[ValidatorType: CoreValidator](
         validator.started_at.value = ""
         validator.completed_at.value = ""
         await validator.save()
-        validator = cast(ValidatorType, validator)
+        validator = cast("ValidatorType", validator)
     else:
         data["proposed_change"] = proposed_change
         validator = await client.create(kind=validator_type, data=data)

infrahub/workers/infrahub_async.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import logging
 import os
 from pathlib import Path
@@ -107,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)
 
@@ -212,18 +213,18 @@ class InfrahubWorkerAsync(BaseWorker):
         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
-            try:
+            with contextlib.suppress(FileExistsError):
                 config_dir.mkdir(exist_ok=True, parents=True)
-            except FileExistsError:
-                pass
             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("*", "--replace-all", setting_name="safe.directory")
         await self._run_git_config_global("true", setting_name="credential.usehttppath")
-        await self._run_git_config_global(config.SETTINGS.dev.git_credential_helper, setting_name="credential.helper")
+        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(

infrahub_sdk/client.py

@@ -34,7 +34,7 @@ from .config import Config
 from .constants import InfrahubClientMode
 from .convert_object_type import CONVERT_OBJECT_MUTATION, ConversionFieldInput
 from .data import RepositoryBranchInfo, RepositoryData
-from .diff import NodeDiff, diff_tree_node_to_node_diff, get_diff_summary_query
+from .diff import DiffTreeData, NodeDiff, diff_tree_node_to_node_diff, get_diff_summary_query, get_diff_tree_query
 from .exceptions import (
     AuthenticationError,
     Error,
@@ -1282,6 +1282,62 @@ class InfrahubClient(BaseClient):
 
         return node_diffs
 
+    async def get_diff_tree(
+        self,
+        branch: str,
+        name: str | None = None,
+        from_time: datetime | None = None,
+        to_time: datetime | None = None,
+        timeout: int | None = None,
+        tracker: str | None = None,
+    ) -> DiffTreeData | None:
+        """Get complete diff tree with metadata and nodes.
+
+        Returns None if no diff exists.
+        """
+        query = get_diff_tree_query()
+        input_data = {"branch_name": branch}
+        if name:
+            input_data["name"] = name
+        if from_time and to_time and from_time > to_time:
+            raise ValueError("from_time must be <= to_time")
+        if from_time:
+            input_data["from_time"] = from_time.isoformat()
+        if to_time:
+            input_data["to_time"] = to_time.isoformat()
+
+        response = await self.execute_graphql(
+            query=query.render(),
+            branch_name=branch,
+            timeout=timeout,
+            tracker=tracker,
+            variables=input_data,
+        )
+
+        diff_tree = response["DiffTree"]
+        if diff_tree is None:
+            return None
+
+        # Convert nodes to NodeDiff objects
+        node_diffs: list[NodeDiff] = []
+        if "nodes" in diff_tree:
+            for node_dict in diff_tree["nodes"]:
+                node_diff = diff_tree_node_to_node_diff(node_dict=node_dict, branch_name=branch)
+                node_diffs.append(node_diff)
+
+        return DiffTreeData(
+            num_added=diff_tree.get("num_added") or 0,
+            num_updated=diff_tree.get("num_updated") or 0,
+            num_removed=diff_tree.get("num_removed") or 0,
+            num_conflicts=diff_tree.get("num_conflicts") or 0,
+            to_time=diff_tree["to_time"],
+            from_time=diff_tree["from_time"],
+            base_branch=diff_tree["base_branch"],
+            diff_branch=diff_tree["diff_branch"],
+            name=diff_tree.get("name"),
+            nodes=node_diffs,
+        )
+
     @overload
     async def allocate_next_ip_address(
         self,
@@ -2520,6 +2576,62 @@ class InfrahubClientSync(BaseClient):
 
         return node_diffs
 
+    def get_diff_tree(
+        self,
+        branch: str,
+        name: str | None = None,
+        from_time: datetime | None = None,
+        to_time: datetime | None = None,
+        timeout: int | None = None,
+        tracker: str | None = None,
+    ) -> DiffTreeData | None:
+        """Get complete diff tree with metadata and nodes.
+
+        Returns None if no diff exists.
+        """
+        query = get_diff_tree_query()
+        input_data = {"branch_name": branch}
+        if name:
+            input_data["name"] = name
+        if from_time and to_time and from_time > to_time:
+            raise ValueError("from_time must be <= to_time")
+        if from_time:
+            input_data["from_time"] = from_time.isoformat()
+        if to_time:
+            input_data["to_time"] = to_time.isoformat()
+
+        response = self.execute_graphql(
+            query=query.render(),
+            branch_name=branch,
+            timeout=timeout,
+            tracker=tracker,
+            variables=input_data,
+        )
+
+        diff_tree = response["DiffTree"]
+        if diff_tree is None:
+            return None
+
+        # Convert nodes to NodeDiff objects
+        node_diffs: list[NodeDiff] = []
+        if "nodes" in diff_tree:
+            for node_dict in diff_tree["nodes"]:
+                node_diff = diff_tree_node_to_node_diff(node_dict=node_dict, branch_name=branch)
+                node_diffs.append(node_diff)
+
+        return DiffTreeData(
+            num_added=diff_tree.get("num_added") or 0,
+            num_updated=diff_tree.get("num_updated") or 0,
+            num_removed=diff_tree.get("num_removed") or 0,
+            num_conflicts=diff_tree.get("num_conflicts") or 0,
+            to_time=diff_tree["to_time"],
+            from_time=diff_tree["from_time"],
+            base_branch=diff_tree["base_branch"],
+            diff_branch=diff_tree["diff_branch"],
+            name=diff_tree.get("name"),
+            nodes=node_diffs,
+        )
+
     @overload
     def allocate_next_ip_address(
         self,

infrahub_sdk/ctl/AGENTS.md

@@ -0,0 +1,67 @@
+# infrahub_sdk/ctl/AGENTS.md
+
+CLI tool (`infrahubctl`) built with Typer/AsyncTyper.
+
+## Command Pattern
+
+```python
+from rich.console import Console
+from ..async_typer import AsyncTyper
+from ..ctl.client import initialize_client
+from ..ctl.utils import catch_exception
+from .parameters import CONFIG_PARAM
+
+console = Console()
+app = AsyncTyper()
+
+@app.command(name="my-command")
+@catch_exception(console=console)
+async def my_command(
+    path: str = typer.Option(".", help="Path to file"),
+    branch: Optional[str] = None,
+    _: str = CONFIG_PARAM,  # Always include, even if unused
+):
+    client = initialize_client(branch=branch)
+    # implementation using Rich for output
+    console.print(Panel("Result", title="Success"))
+```
+
+## File Organization
+
+```text
+infrahub_sdk/ctl/
+├── cli_commands.py    # Entry point, registers subcommands
+├── client.py          # initialize_client(), initialize_client_sync()
+├── utils.py           # catch_exception decorator, parse_cli_vars
+├── parameters.py      # CONFIG_PARAM and shared parameters
+├── branch.py          # Branch subcommands
+├── schema.py          # Schema subcommands
+└── object.py          # Object subcommands
+```
+
+## Registering Commands
+
+```python
+# In cli_commands.py
+from ..ctl.branch import app as branch_app
+app.add_typer(branch_app, name="branch")
+
+# Or for top-level commands
+from .exporter import dump
+app.command(name="dump")(dump)
+```
+
+## Boundaries
+
+✅ **Always**
+
+- Use `@catch_exception(console=console)` decorator
+- Include `CONFIG_PARAM` in all commands
+- Use `initialize_client()` for client creation
+- Use Rich for output (tables, panels, console.print)
+
+🚫 **Never**
+
+- Use plain `print()` statements
+- Instantiate `InfrahubClient` directly (use `initialize_client`)
+- Forget error handling decorator

infrahub_sdk/ctl/branch.py

@@ -1,15 +1,24 @@
 import logging
+import sys
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING
 
 import typer
 from rich.console import Console
 from rich.table import Table
 
 from ..async_typer import AsyncTyper
-from ..utils import calculate_time_diff
+from ..branch import BranchData
+from ..diff import DiffTreeData
+from ..protocols import CoreProposedChange
+from ..utils import calculate_time_diff, decode_json
 from .client import initialize_client
 from .parameters import CONFIG_PARAM
 from .utils import catch_exception
 
+if TYPE_CHECKING:
+    from ..client import InfrahubClient
+
 app = AsyncTyper()
 console = Console()
 
@@ -18,6 +27,108 @@ DEFAULT_CONFIG_FILE = "infrahubctl.toml"
 ENVVAR_CONFIG_FILE = "INFRAHUBCTL_CONFIG"
 
 
+def format_timestamp(timestamp: str) -> str:
+    """Format ISO timestamp to 'YYYY-MM-DD HH:MM:SS'.
+    Args:
+        timestamp (str): ISO fromatted timestamp
+
+    Returns:
+        (str): the datetime as string formatted as 'YYYY-MM-DD HH:MM:SS'
+
+    Raises:
+        Any execptions returned from formatting the timestamp are propogated to the caller
+    """
+    dt = datetime.fromisoformat(timestamp.replace("Z", "+00:00"))
+    return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+
+async def check_git_files_changed(client: "InfrahubClient", branch: str) -> bool:
+    """Check if there are any Git file changes in a branch.
+
+    Args:
+        client: Infrahub client instance
+        branch: Branch name to check
+
+    Returns:
+        True if files have changed, False otherwise
+
+    Raises:
+        Any exceptions from the API call are propagated to the caller
+    """
+    url = f"{client.address}/api/diff/files?branch={branch}"
+    resp = await client._get(url=url, timeout=client.default_timeout)
+    resp.raise_for_status()
+    data = decode_json(response=resp)
+
+    # Check if any repository has files
+    if branch in data:
+        for repo_data in data[branch].values():
+            if isinstance(repo_data, dict) and "files" in repo_data and len(repo_data["files"]) > 0:
+                return True
+
+    return False
+
+
+def generate_branch_report_table(
+    branch: BranchData, diff_tree: DiffTreeData | None, git_files_changed: bool | None
+) -> Table:
+    branch_table = Table(show_header=False, box=None)
+    branch_table.add_column(justify="left")
+    branch_table.add_column(justify="right")
+
+    branch_table.add_row("Created at", format_timestamp(branch.branched_from))
+
+    status_value = branch.status.value if hasattr(branch.status, "value") else str(branch.status)
+    branch_table.add_row("Status", status_value)
+
+    branch_table.add_row("Synced with Git", "Yes" if branch.sync_with_git else "No")
+
+    if git_files_changed is not None:
+        branch_table.add_row("Git files changed", "Yes" if git_files_changed else "No")
+    else:
+        branch_table.add_row("Git files changed", "N/A")
+
+    branch_table.add_row("Has schema changes", "Yes" if branch.has_schema_changes else "No")
+
+    if diff_tree:
+        branch_table.add_row("Diff last updated", format_timestamp(diff_tree["to_time"]))
+        branch_table.add_row("Amount of additions", str(diff_tree["num_added"]))
+        branch_table.add_row("Amount of deletions", str(diff_tree["num_removed"]))
+        branch_table.add_row("Amount of updates", str(diff_tree["num_updated"]))
+        branch_table.add_row("Amount of conflicts", str(diff_tree["num_conflicts"]))
+    else:
+        branch_table.add_row("Diff last updated", "No diff available")
+        branch_table.add_row("Amount of additions", "-")
+        branch_table.add_row("Amount of deletions", "-")
+        branch_table.add_row("Amount of updates", "-")
+        branch_table.add_row("Amount of conflicts", "-")
+
+    return branch_table
+
+
+def generate_proposed_change_tables(proposed_changes: list[CoreProposedChange]) -> list[Table]:
+    proposed_change_tables: list[Table] = []
+
+    for pc in proposed_changes:
+        # Create proposal table
+        proposed_change_table = Table(show_header=False, box=None)
+        proposed_change_table.add_column(justify="left")
+        proposed_change_table.add_column(justify="right")
+
+        # Extract data from node
+        proposed_change_table.add_row("Name", pc.name.value)
+        proposed_change_table.add_row("State", str(pc.state.value))
+        proposed_change_table.add_row("Is draft", "Yes" if pc.is_draft.value else "No")
+        proposed_change_table.add_row("Created by", pc.created_by.peer.name.value)  # type: ignore[union-attr]
+        proposed_change_table.add_row("Created at", format_timestamp(str(pc.created_by.updated_at)))
+        proposed_change_table.add_row("Approvals", str(len(pc.approved_by.peers)))
+        proposed_change_table.add_row("Rejections", str(len(pc.rejected_by.peers)))
+
+        proposed_change_tables.append(proposed_change_table)
+
+    return proposed_change_tables
+
+
 @app.callback()
 def callback() -> None:
     """
@@ -143,3 +254,66 @@ async def validate(branch_name: str, _: str = CONFIG_PARAM) -> None:
     client = initialize_client()
     await client.branch.validate(branch_name=branch_name)
     console.print(f"Branch '{branch_name}' is valid.")
+
+
+@app.command()
+@catch_exception(console=console)
+async def report(
+    branch_name: str = typer.Argument(..., help="Branch name to generate report for"),
+    update_diff: bool = typer.Option(False, "--update-diff", help="Update diff before generating report"),
+    _: str = CONFIG_PARAM,
+) -> None:
+    """Generate branch cleanup status report."""
+
+    client = initialize_client()
+
+    # Fetch branch metadata first (needed for diff creation)
+    branch = await client.branch.get(branch_name=branch_name)
+
+    if branch.is_default:
+        console.print("[red]Cannot create a report for the default branch!")
+        sys.exit(1)
+
+    # Update diff if requested
+    if update_diff:
+        console.print("Updating diff...")
+        # Create diff from branch creation to now
+        from_time = datetime.fromisoformat(branch.branched_from.replace("Z", "+00:00"))
+        to_time = datetime.now(timezone.utc)
+        await client.create_diff(
+            branch=branch_name,
+            name=f"report-{branch_name}",
+            from_time=from_time,
+            to_time=to_time,
+        )
+        console.print("Diff updated\n")
+
+    diff_tree = await client.get_diff_tree(branch=branch_name)
+
+    git_files_changed = await check_git_files_changed(client, branch=branch_name)
+
+    proposed_changes = await client.filters(
+        kind=CoreProposedChange,  # type: ignore[type-abstract]
+        source_branch__value=branch_name,
+        include=["created_by"],
+        prefetch_relationships=True,
+        property=True,
+    )
+
+    branch_table = generate_branch_report_table(branch=branch, diff_tree=diff_tree, git_files_changed=git_files_changed)
+    proposed_change_tables = generate_proposed_change_tables(proposed_changes=proposed_changes)
+
+    console.print()
+    console.print(f"[bold]Branch: {branch_name}[/bold]")
+
+    console.print(branch_table)
+    console.print()
+
+    if not proposed_changes:
+        console.print("No proposed changes for this branch")
+        console.print()
+
+    for proposed_change, proposed_change_table in zip(proposed_changes, proposed_change_tables, strict=True):
+        console.print(f"Proposed change: {proposed_change.name.value}")
+        console.print(proposed_change_table)
+        console.print()

infrahub_sdk/ctl/check.py

@@ -5,7 +5,7 @@ import sys
 from asyncio import run as aiorun
 from dataclasses import dataclass
 from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import TYPE_CHECKING
 
 import typer
 from rich.console import Console
@@ -49,8 +49,8 @@ def run(
     format_json: bool,
     list_available: bool,
     variables: dict[str, str],
-    name: Optional[str] = None,
-    branch: Optional[str] = None,
+    name: str | None = None,
+    branch: str | None = None,
 ) -> None:
     """Locate and execute all checks under the defined path."""