infrahub-server 1.4.13__py3-none-any.whl → 1.5.0__py3-none-any.whl

infrahub_sdk/ctl/task.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from ..async_typer import AsyncTyper
+from ..task.manager import TaskFilter
+from ..task.models import Task, TaskState
+from .client import initialize_client
+from .parameters import CONFIG_PARAM
+from .utils import catch_exception, init_logging
+
+app = AsyncTyper()
+console = Console()
+
+
+@app.callback()
+def callback() -> None:
+    """Manage Infrahub tasks."""
+
+
+def _parse_states(states: list[str] | None) -> list[TaskState] | None:
+    if not states:
+        return None
+
+    parsed_states: list[TaskState] = []
+    for state in states:
+        normalized_state = state.strip().upper()
+        try:
+            parsed_states.append(TaskState(normalized_state))
+        except ValueError as exc:  # pragma: no cover - typer will surface this as CLI error
+            raise typer.BadParameter(
+                f"Unsupported state '{state}'. Available states: {', '.join(item.value.lower() for item in TaskState)}"
+            ) from exc
+
+    return parsed_states
+
+
+def _render_table(tasks: list[Task]) -> None:
+    table = Table(title="Infrahub Tasks", box=None)
+    table.add_column("ID", style="cyan", overflow="fold")
+    table.add_column("Title", style="magenta", overflow="fold")
+    table.add_column("State", style="green")
+    table.add_column("Progress", justify="right")
+    table.add_column("Workflow", overflow="fold")
+    table.add_column("Branch", overflow="fold")
+    table.add_column("Updated")
+
+    if not tasks:
+        table.add_row("-", "No tasks found", "-", "-", "-", "-", "-")
+        console.print(table)
+        return
+
+    for task in tasks:
+        progress = f"{task.progress:.0%}" if task.progress is not None else "-"
+        table.add_row(
+            task.id,
+            task.title,
+            task.state.value,
+            progress,
+            task.workflow or "-",
+            task.branch or "-",
+            task.updated_at.isoformat(),
+        )
+
+    console.print(table)
+
+
+@app.command(name="list")
+@catch_exception(console=console)
+async def list_tasks(
+    state: list[str] = typer.Option(
+        None, "--state", "-s", help="Filter by task state. Can be provided multiple times."
+    ),
+    limit: Optional[int] = typer.Option(None, help="Maximum number of tasks to retrieve."),
+    offset: Optional[int] = typer.Option(None, help="Offset for pagination."),
+    include_related_nodes: bool = typer.Option(False, help="Include related nodes in the output."),
+    include_logs: bool = typer.Option(False, help="Include task logs in the output."),
+    json_output: bool = typer.Option(False, "--json", help="Output the result as JSON."),
+    debug: bool = False,
+    _: str = CONFIG_PARAM,
+) -> None:
+    """List Infrahub tasks."""
+
+    init_logging(debug=debug)
+
+    client = initialize_client()
+    filters = TaskFilter()
+    parsed_states = _parse_states(state)
+    if parsed_states:
+        filters.state = parsed_states
+
+    tasks = await client.task.filter(
+        filter=filters,
+        limit=limit,
+        offset=offset,
+        include_related_nodes=include_related_nodes,
+        include_logs=include_logs,
+    )
+
+    if json_output:
+        console.print_json(
+            data=[task.model_dump(mode="json") for task in tasks], indent=2, sort_keys=True, highlight=False
+        )
+        return
+
+    _render_table(tasks)

infrahub_sdk/ctl/utils.py

@@ -118,6 +118,10 @@ def execute_graphql_query(
     query_str = query_object.load_query()
 
     client = initialize_client_sync()
+
+    if not branch:
+        branch = client.config.default_infrahub_branch
+
     response = client.execute_graphql(
         query=query_str,
         branch_name=branch,

infrahub_sdk/ctl/validate.py

@@ -14,7 +14,7 @@ from ..ctl.client import initialize_client, initialize_client_sync
 from ..ctl.exceptions import QueryNotFoundError
 from ..ctl.utils import catch_exception, find_graphql_query, parse_cli_vars
 from ..exceptions import GraphQLError
-from ..utils import get_branch, write_to_file
+from ..utils import write_to_file
 from ..yaml import SchemaFile
 from .parameters import CONFIG_PARAM
 from .utils import load_yamlfile_from_disk_and_exit
@@ -68,8 +68,6 @@ def validate_graphql(
 ) -> None:
     """Validate the format of a GraphQL Query stored locally by executing it on a remote GraphQL endpoint"""
 
-    branch = get_branch(branch)
-
     try:
         query_str = find_graphql_query(query)
     except QueryNotFoundError:
@@ -81,6 +79,10 @@ def validate_graphql(
     variables_dict = parse_cli_vars(variables)
 
     client = initialize_client_sync()
+
+    if not branch:
+        branch = client.config.default_infrahub_branch
+
     try:
         response = client.execute_graphql(
             query=query_str,

infrahub_sdk/diff.py

@@ -37,8 +37,8 @@ class NodeDiffPeer(TypedDict):
 
 def get_diff_summary_query() -> str:
     return """
-        query GetDiffTree($branch_name: String!) {
-            DiffTree(branch: $branch_name) {
+        query GetDiffTree($branch_name: String!, $name: String, $from_time: DateTime, $to_time: DateTime) {
+            DiffTree(branch: $branch_name, name: $name, from_time: $from_time, to_time: $to_time) {
                 nodes {
                     uuid
                     kind
@@ -117,12 +117,11 @@ def diff_tree_node_to_node_diff(node_dict: dict[str, Any], branch_name: str) ->
                     )
                 relationship_diff["peers"] = peer_diffs
             element_diffs.append(relationship_diff)
-    node_diff = NodeDiff(
+    return NodeDiff(
         branch=branch_name,
         kind=str(node_dict.get("kind")),
         id=str(node_dict.get("uuid")),
-        action=str(node_dict.get("action")),
+        action=str(node_dict.get("status")),
         display_label=str(node_dict.get("label")),
         elements=element_diffs,
     )
-    return node_diff

infrahub_sdk/exceptions.py

@@ -17,6 +17,8 @@ class JsonDecodeError(Error):
         self.url = url
         if not self.message and self.url:
             self.message = f"Unable to decode response as JSON data from {self.url}"
+            if self.content:
+                self.message += f". Server response: {self.content}"
         super().__init__(self.message)
 
 

infrahub_sdk/generator.py

@@ -26,6 +26,8 @@ class InfrahubGenerator(InfrahubOperation):
         generator_instance: str = "",
         params: dict | None = None,
         convert_query_response: bool = False,
+        execute_in_proposed_change: bool = True,
+        execute_after_merge: bool = True,
         logger: logging.Logger | None = None,
         request_context: RequestContext | None = None,
     ) -> None:
@@ -44,6 +46,8 @@ class InfrahubGenerator(InfrahubOperation):
         self._client: InfrahubClient | None = None
         self.logger = logger if logger else logging.getLogger("infrahub.tasks")
         self.request_context = request_context
+        self.execute_in_proposed_change = execute_in_proposed_change
+        self.execute_after_merge = execute_after_merge
 
     @property
     def subscribers(self) -> list[str] | None:
@@ -81,8 +85,10 @@ class InfrahubGenerator(InfrahubOperation):
         unpacked = data.get("data") or data
         await self.process_nodes(data=unpacked)
 
+        group_type = "CoreGeneratorGroup" if self.execute_after_merge else "CoreGeneratorAwareGroup"
+
         async with self._init_client.start_tracking(
-            identifier=identifier, params=self.params, delete_unused_nodes=True, group_type="CoreGeneratorGroup"
+            identifier=identifier, params=self.params, delete_unused_nodes=True, group_type=group_type
         ) as self.client:
             await self.generate(data=unpacked)
 

infrahub_sdk/graphql/__init__.py

@@ -0,0 +1,12 @@
+from .constants import VARIABLE_TYPE_MAPPING
+from .query import Mutation, Query
+from .renderers import render_input_block, render_query_block, render_variables_to_string
+
+__all__ = [
+    "VARIABLE_TYPE_MAPPING",
+    "Mutation",
+    "Query",
+    "render_input_block",
+    "render_query_block",
+    "render_variables_to_string",
+]

infrahub_sdk/graphql/constants.py

@@ -0,0 +1 @@
+VARIABLE_TYPE_MAPPING = ((str, "String!"), (int, "Int!"), (float, "Float!"), (bool, "Boolean!"))

infrahub_sdk/graphql/plugin.py

@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import ast
+from typing import TYPE_CHECKING
+
+from ariadne_codegen.plugins.base import Plugin
+
+if TYPE_CHECKING:
+    from graphql import ExecutableDefinitionNode
+
+
+class FutureAnnotationPlugin(Plugin):
+    @staticmethod
+    def insert_future_annotation(module: ast.Module) -> ast.Module:
+        # First check if the future annotation is already present
+        for item in module.body:
+            if isinstance(item, ast.ImportFrom) and item.module == "__future__":
+                if any(alias.name == "annotations" for alias in item.names):
+                    return module
+
+        module.body.insert(0, ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0))
+        return module
+
+    def generate_result_types_module(
+        self,
+        module: ast.Module,
+        operation_definition: ExecutableDefinitionNode,  # noqa: ARG002
+    ) -> ast.Module:
+        return self.insert_future_annotation(module)
+
+
+class StandardTypeHintPlugin(Plugin):
+    @classmethod
+    def replace_list_in_subscript(cls, subscript: ast.Subscript) -> ast.Subscript:
+        if isinstance(subscript.value, ast.Name) and subscript.value.id == "List":
+            subscript.value.id = "list"
+        if isinstance(subscript.slice, ast.Subscript):
+            subscript.slice = cls.replace_list_in_subscript(subscript.slice)
+
+        return subscript
+
+    @classmethod
+    def replace_list_annotations(cls, module: ast.Module) -> ast.Module:
+        for item in module.body:
+            if not isinstance(item, ast.ClassDef):
+                continue
+
+            # replace List with list in the annotations when list is used as a type
+            for class_item in item.body:
+                if not isinstance(class_item, ast.AnnAssign):
+                    continue
+                if isinstance(class_item.annotation, ast.Subscript):
+                    class_item.annotation = cls.replace_list_in_subscript(class_item.annotation)
+
+        return module
+
+    def generate_result_types_module(
+        self,
+        module: ast.Module,
+        operation_definition: ExecutableDefinitionNode,  # noqa: ARG002
+    ) -> ast.Module:
+        module = FutureAnnotationPlugin.insert_future_annotation(module)
+        return self.replace_list_annotations(module)
+
+
+class PydanticBaseModelPlugin(Plugin):
+    @staticmethod
+    def find_base_model_index(module: ast.Module) -> int:
+        for idx, item in enumerate(module.body):
+            if isinstance(item, ast.ImportFrom) and item.module == "base_model":
+                return idx
+        raise ValueError("BaseModel not found in module")
+
+    @classmethod
+    def replace_base_model_import(cls, module: ast.Module) -> ast.Module:
+        base_model_index = cls.find_base_model_index(module)
+        module.body[base_model_index] = ast.ImportFrom(module="pydantic", names=[ast.alias(name="BaseModel")], level=0)
+        return module
+
+    def generate_result_types_module(
+        self,
+        module: ast.Module,
+        operation_definition: ExecutableDefinitionNode,  # noqa: ARG002
+    ) -> ast.Module:
+        return self.replace_base_model_import(module)

infrahub_sdk/graphql/query.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .renderers import render_input_block, render_query_block, render_variables_to_string
+
+
+class BaseGraphQLQuery:
+    query_type: str = "not-defined"
+    indentation: int = 4
+
+    def __init__(self, query: dict, variables: dict | None = None, name: str | None = None):
+        self.query = query
+        self.variables = variables
+        self.name = name or ""
+
+    def render_first_line(self) -> str:
+        first_line = self.query_type
+
+        if self.name:
+            first_line += " " + self.name
+
+        if self.variables:
+            first_line += f" ({render_variables_to_string(self.variables)})"
+
+        first_line += " {"
+
+        return first_line
+
+
+class Query(BaseGraphQLQuery):
+    query_type = "query"
+
+    def render(self, convert_enum: bool = False) -> str:
+        lines = [self.render_first_line()]
+        lines.extend(
+            render_query_block(
+                data=self.query, indentation=self.indentation, offset=self.indentation, convert_enum=convert_enum
+            )
+        )
+        lines.append("}")
+
+        return "\n" + "\n".join(lines) + "\n"
+
+
+class Mutation(BaseGraphQLQuery):
+    query_type = "mutation"
+
+    def __init__(self, *args: Any, mutation: str, input_data: dict, **kwargs: Any):
+        self.input_data = input_data
+        self.mutation = mutation
+        super().__init__(*args, **kwargs)
+
+    def render(self, convert_enum: bool = False) -> str:
+        lines = [self.render_first_line()]
+        lines.append(" " * self.indentation + f"{self.mutation}(")
+        lines.extend(
+            render_input_block(
+                data=self.input_data,
+                indentation=self.indentation,
+                offset=self.indentation * 2,
+                convert_enum=convert_enum,
+            )
+        )
+        lines.append(" " * self.indentation + "){")
+        lines.extend(
+            render_query_block(
+                data=self.query,
+                indentation=self.indentation,
+                offset=self.indentation * 2,
+                convert_enum=convert_enum,
+            )
+        )
+        lines.append(" " * self.indentation + "}")
+        lines.append("}")
+
+        return "\n" + "\n".join(lines) + "\n"

infrahub_sdk/{graphql.py → graphql/renderers.py}

@@ -1,14 +1,42 @@
 from __future__ import annotations
 
+import json
 from enum import Enum
 from typing import Any
 
 from pydantic import BaseModel
 
-VARIABLE_TYPE_MAPPING = ((str, "String!"), (int, "Int!"), (float, "Float!"), (bool, "Boolean!"))
+from .constants import VARIABLE_TYPE_MAPPING
 
 
-def convert_to_graphql_as_string(value: str | bool | list | BaseModel | Enum | Any, convert_enum: bool = False) -> str:  # noqa: PLR0911
+def convert_to_graphql_as_string(value: Any, convert_enum: bool = False) -> str:  # noqa: PLR0911
+    """Convert a Python value to its GraphQL string representation.
+
+    This function handles various Python types and converts them to their appropriate
+    GraphQL string format, including proper quoting, formatting, and special handling
+    for different data types.
+
+    Args:
+        value: The value to convert to GraphQL string format. Can be None, str, bool,
+            int, float, Enum, list, BaseModel, or any other type.
+        convert_enum: If True, converts Enum values to their underlying value instead
+            of their name. Defaults to False.
+
+    Returns:
+        str: The GraphQL string representation of the value.
+
+    Examples:
+        >>> convert_to_graphql_as_string("hello")
+        '"hello"'
+        >>> convert_to_graphql_as_string(True)
+        'true'
+        >>> convert_to_graphql_as_string([1, 2, 3])
+        '[1, 2, 3]'
+        >>> convert_to_graphql_as_string(None)
+        'null'
+    """
+    if value is None:
+        return "null"
     if isinstance(value, str) and value.startswith("$"):
         return value
     if isinstance(value, Enum):
@@ -16,7 +44,9 @@ def convert_to_graphql_as_string(value: str | bool | list | BaseModel | Enum | A
             return convert_to_graphql_as_string(value=value.value, convert_enum=True)
         return value.name
     if isinstance(value, str):
-        return f'"{value}"'
+        # Use json.dumps() to properly escape the string according to JSON rules,
+        # which are compatible with GraphQL string escaping
+        return json.dumps(value)
     if isinstance(value, bool):
         return repr(value).lower()
     if isinstance(value, list):
@@ -51,6 +81,34 @@ def render_variables_to_string(data: dict[str, type[str | int | float | bool]])
 
 
 def render_query_block(data: dict, offset: int = 4, indentation: int = 4, convert_enum: bool = False) -> list[str]:
+    """Render a dictionary structure as a GraphQL query block with proper formatting.
+
+    This function recursively processes a dictionary to generate GraphQL query syntax
+    with proper indentation, handling of aliases, filters, and nested structures.
+    Special keys like "@filters" and "@alias" are processed for GraphQL-specific
+    formatting.
+
+    Args:
+        data: Dictionary representing the GraphQL query structure. Can contain
+            nested dictionaries, special keys like "@filters" and "@alias", and
+            various value types.
+        offset: Number of spaces to use for initial indentation. Defaults to 4.
+        indentation: Number of spaces to add for each nesting level. Defaults to 4.
+        convert_enum: If True, converts Enum values to their underlying value.
+            Defaults to False.
+
+    Returns:
+        list[str]: List of formatted lines representing the GraphQL query block.
+
+    Examples:
+        >>> data = {"user": {"name": None, "email": None}}
+        >>> render_query_block(data)
+        ['    user {', '        name', '        email', '    }']
+
+        >>> data = {"user": {"@alias": "u", "@filters": {"id": 123}, "name": None}}
+        >>> render_query_block(data)
+        ['    u: user(id: 123) {', '        name', '    }']
+    """
     FILTERS_KEY = "@filters"
     ALIAS_KEY = "@alias"
     KEYWORDS_TO_SKIP = [FILTERS_KEY, ALIAS_KEY]
@@ -92,6 +150,33 @@ def render_query_block(data: dict, offset: int = 4, indentation: int = 4, conver
 
 
 def render_input_block(data: dict, offset: int = 4, indentation: int = 4, convert_enum: bool = False) -> list[str]:
+    """Render a dictionary structure as a GraphQL input block with proper formatting.
+
+    This function recursively processes a dictionary to generate GraphQL input syntax
+    with proper indentation, handling nested objects, arrays, and various data types.
+    Unlike query blocks, input blocks don't handle special keys like "@filters" or
+    "@alias" and focus on data structure representation.
+
+    Args:
+        data: Dictionary representing the GraphQL input structure. Can contain
+            nested dictionaries, lists, and various value types.
+        offset: Number of spaces to use for initial indentation. Defaults to 4.
+        indentation: Number of spaces to add for each nesting level. Defaults to 4.
+        convert_enum: If True, converts Enum values to their underlying value.
+            Defaults to False.
+
+    Returns:
+        list[str]: List of formatted lines representing the GraphQL input block.
+
+    Examples:
+        >>> data = {"name": "John", "age": 30}
+        >>> render_input_block(data)
+        ['    name: "John"', '    age: 30']
+
+        >>> data = {"user": {"name": "John", "hobbies": ["reading", "coding"]}}
+        >>> render_input_block(data)
+        ['    user: {', '        name: "John"', '        hobbies: [', '            "reading",', '            "coding",', '        ]', '    }']
+    """
     offset_str = " " * offset
     lines = []
     for key, value in data.items():
@@ -125,75 +210,3 @@ def render_input_block(data: dict, offset: int = 4, indentation: int = 4, conver
         else:
             lines.append(f"{offset_str}{key}: {convert_to_graphql_as_string(value=value, convert_enum=convert_enum)}")
     return lines
-
-
-class BaseGraphQLQuery:
-    query_type: str = "not-defined"
-    indentation: int = 4
-
-    def __init__(self, query: dict, variables: dict | None = None, name: str | None = None):
-        self.query = query
-        self.variables = variables
-        self.name = name or ""
-
-    def render_first_line(self) -> str:
-        first_line = self.query_type
-
-        if self.name:
-            first_line += " " + self.name
-
-        if self.variables:
-            first_line += f" ({render_variables_to_string(self.variables)})"
-
-        first_line += " {"
-
-        return first_line
-
-
-class Query(BaseGraphQLQuery):
-    query_type = "query"
-
-    def render(self, convert_enum: bool = False) -> str:
-        lines = [self.render_first_line()]
-        lines.extend(
-            render_query_block(
-                data=self.query, indentation=self.indentation, offset=self.indentation, convert_enum=convert_enum
-            )
-        )
-        lines.append("}")
-
-        return "\n" + "\n".join(lines) + "\n"
-
-
-class Mutation(BaseGraphQLQuery):
-    query_type = "mutation"
-
-    def __init__(self, *args: Any, mutation: str, input_data: dict, **kwargs: Any):
-        self.input_data = input_data
-        self.mutation = mutation
-        super().__init__(*args, **kwargs)
-
-    def render(self, convert_enum: bool = False) -> str:
-        lines = [self.render_first_line()]
-        lines.append(" " * self.indentation + f"{self.mutation}(")
-        lines.extend(
-            render_input_block(
-                data=self.input_data,
-                indentation=self.indentation,
-                offset=self.indentation * 2,
-                convert_enum=convert_enum,
-            )
-        )
-        lines.append(" " * self.indentation + "){")
-        lines.extend(
-            render_query_block(
-                data=self.query,
-                indentation=self.indentation,
-                offset=self.indentation * 2,
-                convert_enum=convert_enum,
-            )
-        )
-        lines.append(" " * self.indentation + "}")
-        lines.append("}")
-
-        return "\n" + "\n".join(lines) + "\n"

infrahub_sdk/graphql/utils.py

@@ -0,0 +1,40 @@
+import ast
+
+
+def get_class_def_index(module: ast.Module) -> int:
+    """Get the index of the first class definition in the module.
+    It's useful to insert other classes before the first class definition."""
+    for idx, item in enumerate(module.body):
+        if isinstance(item, ast.ClassDef):
+            return idx
+    return -1
+
+
+def insert_fragments_inline(module: ast.Module, fragment: ast.Module) -> ast.Module:
+    """Insert the Pydantic classes for the fragments inline into the module.
+
+    If no class definitions exist in module, fragments are appended to the end.
+    """
+    module_class_def_index = get_class_def_index(module)
+
+    fragment_classes: list[ast.ClassDef] = [item for item in fragment.body if isinstance(item, ast.ClassDef)]
+
+    # Handle edge case when no class definitions exist
+    if module_class_def_index == -1:
+        # Append fragments to the end of the module
+        module.body.extend(fragment_classes)
+    else:
+        # Insert fragments before the first class definition
+        for idx, item in enumerate(fragment_classes):
+            module.body.insert(module_class_def_index + idx, item)
+
+    return module
+
+
+def remove_fragment_import(module: ast.Module) -> ast.Module:
+    """Remove the fragment import from the module."""
+    for item in module.body:
+        if isinstance(item, ast.ImportFrom) and item.module == "fragments":
+            module.body.remove(item)
+            return module
+    return module

infrahub_sdk/node/attribute.py

@@ -76,6 +76,8 @@ class Attribute:
         variables: dict[str, Any] = {}
 
         if self.value is None:
+            if self._schema.optional and self.value_has_been_mutated:
+                data["value"] = None
             return data
 
         if isinstance(self.value, str):