infrahub-server 1.1.1__py3-none-any.whl → 1.1.3__py3-none-any.whl

infrahub_sdk/client.py

@@ -46,13 +46,13 @@ from .node import (
 )
 from .object_store import ObjectStore, ObjectStoreSync
 from .protocols_base import CoreNode, CoreNodeSync
-from .queries import get_commit_update_mutation
+from .queries import QUERY_USER, get_commit_update_mutation
 from .query_groups import InfrahubGroupContext, InfrahubGroupContextSync
 from .schema import InfrahubSchema, InfrahubSchemaSync, NodeSchemaAPI
 from .store import NodeStore, NodeStoreSync
 from .timestamp import Timestamp
-from .types import AsyncRequester, HTTPMethod, SyncRequester
-from .utils import decode_json, is_valid_uuid
+from .types import AsyncRequester, HTTPMethod, Order, SyncRequester
+from .utils import decode_json, get_user_permissions, is_valid_uuid
 
 if TYPE_CHECKING:
     from types import TracebackType
@@ -272,6 +272,22 @@ class InfrahubClient(BaseClient):
         self._request_method: AsyncRequester = self.config.requester or self._default_request_method
         self.group_context = InfrahubGroupContext(self)
 
+    async def get_version(self) -> str:
+        """Return the Infrahub version."""
+        response = await self.execute_graphql(query="query { InfrahubInfo { version }}")
+        version = response.get("InfrahubInfo", {}).get("version", "")
+        return version
+
+    async def get_user(self) -> dict:
+        """Return user information"""
+        user_info = await self.execute_graphql(query=QUERY_USER)
+        return user_info
+
+    async def get_user_permissions(self) -> dict:
+        """Return user permissions"""
+        user_info = await self.get_user()
+        return get_user_permissions(user_info["AccountProfile"]["member_of_groups"]["edges"])
+
     @overload
     async def create(
         self,
@@ -525,6 +541,25 @@ class InfrahubClient(BaseClient):
 
         return ProcessRelationsNode(nodes=nodes, related_nodes=related_nodes)
 
+    async def count(
+        self,
+        kind: str | type[SchemaType],
+        at: Timestamp | None = None,
+        branch: str | None = None,
+        timeout: int | None = None,
+    ) -> int:
+        """Return the number of nodes of a given kind."""
+        schema = await self.schema.get(kind=kind, branch=branch)
+
+        branch = branch or self.default_branch
+        if at:
+            at = Timestamp(at)
+
+        response = await self.execute_graphql(
+            query=Query(query={schema.kind: {"count": None}}).render(), branch_name=branch, at=at, timeout=timeout
+        )
+        return int(response.get(schema.kind, {}).get("count", 0))
+
     @overload
     async def all(
         self,
@@ -540,6 +575,8 @@ class InfrahubClient(BaseClient):
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
+        parallel: bool = ...,
+        order: Order | None = ...,
     ) -> list[SchemaType]: ...
 
     @overload
@@ -557,6 +594,8 @@ class InfrahubClient(BaseClient):
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
+        parallel: bool = ...,
+        order: Order | None = ...,
     ) -> list[InfrahubNode]: ...
 
     async def all(
@@ -573,6 +612,8 @@ class InfrahubClient(BaseClient):
         fragment: bool = False,
         prefetch_relationships: bool = False,
         property: bool = False,
+        parallel: bool = False,
+        order: Order | None = None,
     ) -> list[InfrahubNode] | list[SchemaType]:
         """Retrieve all nodes of a given kind
 
@@ -588,6 +629,8 @@ class InfrahubClient(BaseClient):
             exclude (list[str], optional): List of attributes or relationships to exclude from the query.
             fragment (bool, optional): Flag to use GraphQL fragments for generic schemas.
             prefetch_relationships (bool, optional): Flag to indicate whether to prefetch related node data.
+            parallel (bool, optional): Whether to use parallel processing for the query.
+            order (Order, optional): Ordering related options. Setting `disable=True` enhances performances.
 
         Returns:
             list[InfrahubNode]: List of Nodes
@@ -605,6 +648,8 @@ class InfrahubClient(BaseClient):
             fragment=fragment,
             prefetch_relationships=prefetch_relationships,
             property=property,
+            parallel=parallel,
+            order=order,
         )
 
     @overload
@@ -623,6 +668,8 @@ class InfrahubClient(BaseClient):
         prefetch_relationships: bool = ...,
         partial_match: bool = ...,
         property: bool = ...,
+        parallel: bool = ...,
+        order: Order | None = ...,
         **kwargs: Any,
     ) -> list[SchemaType]: ...
 
@@ -642,6 +689,8 @@ class InfrahubClient(BaseClient):
         prefetch_relationships: bool = ...,
         partial_match: bool = ...,
         property: bool = ...,
+        parallel: bool = ...,
+        order: Order | None = ...,
         **kwargs: Any,
     ) -> list[InfrahubNode]: ...
 
@@ -660,6 +709,8 @@ class InfrahubClient(BaseClient):
         prefetch_relationships: bool = False,
         partial_match: bool = False,
         property: bool = False,
+        parallel: bool = False,
+        order: Order | None = None,
         **kwargs: Any,
     ) -> list[InfrahubNode] | list[SchemaType]:
         """Retrieve nodes of a given kind based on provided filters.
@@ -677,32 +728,27 @@ class InfrahubClient(BaseClient):
             fragment (bool, optional): Flag to use GraphQL fragments for generic schemas.
             prefetch_relationships (bool, optional): Flag to indicate whether to prefetch related node data.
             partial_match (bool, optional): Allow partial match of filter criteria for the query.
+            parallel (bool, optional): Whether to use parallel processing for the query.
+            order (Order, optional): Ordering related options. Setting `disable=True` enhances performances.
             **kwargs (Any): Additional filter criteria for the query.
 
         Returns:
             list[InfrahubNodeSync]: List of Nodes that match the given filters.
         """
-        schema = await self.schema.get(kind=kind, branch=branch)
-
         branch = branch or self.default_branch
+        schema = await self.schema.get(kind=kind, branch=branch)
         if at:
             at = Timestamp(at)
 
         node = InfrahubNode(client=self, schema=schema, branch=branch)
         filters = kwargs
+        pagination_size = self.pagination_size
 
-        nodes: list[InfrahubNode] = []
-        related_nodes: list[InfrahubNode] = []
-
-        has_remaining_items = True
-        page_number = 1
-
-        while has_remaining_items:
-            page_offset = (page_number - 1) * self.pagination_size
-
+        async def process_page(page_offset: int, page_number: int) -> tuple[dict, ProcessRelationsNode]:
+            """Process a single page of results."""
             query_data = await InfrahubNode(client=self, schema=schema, branch=branch).generate_query_data(
                 offset=offset or page_offset,
-                limit=limit or self.pagination_size,
+                limit=limit or pagination_size,
                 filters=filters,
                 include=include,
                 exclude=exclude,
@@ -710,6 +756,7 @@ class InfrahubClient(BaseClient):
                 prefetch_relationships=prefetch_relationships,
                 partial_match=partial_match,
                 property=property,
+                order=order,
             )
             query = Query(query=query_data)
             response = await self.execute_graphql(
@@ -727,14 +774,48 @@ class InfrahubClient(BaseClient):
                 prefetch_relationships=prefetch_relationships,
                 timeout=timeout,
             )
-            nodes.extend(process_result["nodes"])
-            related_nodes.extend(process_result["related_nodes"])
+            return response, process_result
+
+        async def process_batch() -> tuple[list[InfrahubNode], list[InfrahubNode]]:
+            """Process queries in parallel mode."""
+            nodes = []
+            related_nodes = []
+            batch_process = await self.create_batch()
+            count = await self.count(kind=schema.kind)
+            total_pages = (count + pagination_size - 1) // pagination_size
+
+            for page_number in range(1, total_pages + 1):
+                page_offset = (page_number - 1) * pagination_size
+                batch_process.add(task=process_page, node=node, page_offset=page_offset, page_number=page_number)
 
-            remaining_items = response[schema.kind].get("count", 0) - (page_offset + self.pagination_size)
-            if remaining_items < 0 or offset is not None or limit is not None:
-                has_remaining_items = False
+            async for _, response in batch_process.execute():
+                nodes.extend(response[1]["nodes"])
+                related_nodes.extend(response[1]["related_nodes"])
 
-            page_number += 1
+            return nodes, related_nodes
+
+        async def process_non_batch() -> tuple[list[InfrahubNode], list[InfrahubNode]]:
+            """Process queries without parallel mode."""
+            nodes = []
+            related_nodes = []
+            has_remaining_items = True
+            page_number = 1
+
+            while has_remaining_items:
+                page_offset = (page_number - 1) * pagination_size
+                response, process_result = await process_page(page_offset, page_number)
+
+                nodes.extend(process_result["nodes"])
+                related_nodes.extend(process_result["related_nodes"])
+                remaining_items = response[schema.kind].get("count", 0) - (page_offset + pagination_size)
+                if remaining_items < 0 or offset is not None or limit is not None:
+                    has_remaining_items = False
+                page_number += 1
+
+            return nodes, related_nodes
+
+        # Select parallel or non-parallel processing
+        nodes, related_nodes = await (process_batch() if parallel else process_non_batch())
 
         if populate_store:
             for node in nodes:
@@ -744,7 +825,6 @@ class InfrahubClient(BaseClient):
             for node in related_nodes:
                 if node.id:
                     self.store.set(key=node.id, node=node)
-
         return nodes
 
     def clone(self) -> InfrahubClient:
@@ -1425,6 +1505,22 @@ class InfrahubClientSync(BaseClient):
         self._request_method: SyncRequester = self.config.sync_requester or self._default_request_method
         self.group_context = InfrahubGroupContextSync(self)
 
+    def get_version(self) -> str:
+        """Return the Infrahub version."""
+        response = self.execute_graphql(query="query { InfrahubInfo { version }}")
+        version = response.get("InfrahubInfo", {}).get("version", "")
+        return version
+
+    def get_user(self) -> dict:
+        """Return user information"""
+        user_info = self.execute_graphql(query=QUERY_USER)
+        return user_info
+
+    def get_user_permissions(self) -> dict:
+        """Return user permissions"""
+        user_info = self.get_user()
+        return get_user_permissions(user_info["AccountProfile"]["member_of_groups"]["edges"])
+
     @overload
     def create(
         self,
@@ -1549,6 +1645,25 @@ class InfrahubClientSync(BaseClient):
 
         # TODO add a special method to execute mutation that will check if the method returned OK
 
+    def count(
+        self,
+        kind: str | type[SchemaType],
+        at: Timestamp | None = None,
+        branch: str | None = None,
+        timeout: int | None = None,
+    ) -> int:
+        """Return the number of nodes of a given kind."""
+        schema = self.schema.get(kind=kind, branch=branch)
+
+        branch = branch or self.default_branch
+        if at:
+            at = Timestamp(at)
+
+        response = self.execute_graphql(
+            query=Query(query={schema.kind: {"count": None}}).render(), branch_name=branch, at=at, timeout=timeout
+        )
+        return int(response.get(schema.kind, {}).get("count", 0))
+
     @overload
     def all(
         self,
@@ -1564,6 +1679,8 @@ class InfrahubClientSync(BaseClient):
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
+        parallel: bool = ...,
+        order: Order | None = ...,
     ) -> list[SchemaTypeSync]: ...
 
     @overload
@@ -1581,6 +1698,8 @@ class InfrahubClientSync(BaseClient):
         fragment: bool = ...,
         prefetch_relationships: bool = ...,
         property: bool = ...,
+        parallel: bool = ...,
+        order: Order | None = ...,
     ) -> list[InfrahubNodeSync]: ...
 
     def all(
@@ -1597,6 +1716,8 @@ class InfrahubClientSync(BaseClient):
         fragment: bool = False,
         prefetch_relationships: bool = False,
         property: bool = False,
+        parallel: bool = False,
+        order: Order | None = None,
     ) -> list[InfrahubNodeSync] | list[SchemaTypeSync]:
         """Retrieve all nodes of a given kind
 
@@ -1612,6 +1733,8 @@ class InfrahubClientSync(BaseClient):
             exclude (list[str], optional): List of attributes or relationships to exclude from the query.
             fragment (bool, optional): Flag to use GraphQL fragments for generic schemas.
             prefetch_relationships (bool, optional): Flag to indicate whether to prefetch related node data.
+            parallel (bool, optional): Whether to use parallel processing for the query.
+            order (Order, optional): Ordering related options. Setting `disable=True` enhances performances.
 
         Returns:
             list[InfrahubNodeSync]: List of Nodes
@@ -1629,6 +1752,8 @@ class InfrahubClientSync(BaseClient):
             fragment=fragment,
             prefetch_relationships=prefetch_relationships,
             property=property,
+            parallel=parallel,
+            order=order,
         )
 
     def _process_nodes_and_relationships(
@@ -1682,6 +1807,8 @@ class InfrahubClientSync(BaseClient):
         prefetch_relationships: bool = ...,
         partial_match: bool = ...,
         property: bool = ...,
+        parallel: bool = ...,
+        order: Order | None = ...,
         **kwargs: Any,
     ) -> list[SchemaTypeSync]: ...
 
@@ -1701,6 +1828,8 @@ class InfrahubClientSync(BaseClient):
         prefetch_relationships: bool = ...,
         partial_match: bool = ...,
         property: bool = ...,
+        parallel: bool = ...,
+        order: Order | None = ...,
         **kwargs: Any,
     ) -> list[InfrahubNodeSync]: ...
 
@@ -1719,6 +1848,8 @@ class InfrahubClientSync(BaseClient):
         prefetch_relationships: bool = False,
         partial_match: bool = False,
         property: bool = False,
+        parallel: bool = False,
+        order: Order | None = None,
         **kwargs: Any,
     ) -> list[InfrahubNodeSync] | list[SchemaTypeSync]:
         """Retrieve nodes of a given kind based on provided filters.
@@ -1736,32 +1867,26 @@ class InfrahubClientSync(BaseClient):
             fragment (bool, optional): Flag to use GraphQL fragments for generic schemas.
             prefetch_relationships (bool, optional): Flag to indicate whether to prefetch related node data.
             partial_match (bool, optional): Allow partial match of filter criteria for the query.
+            parallel (bool, optional): Whether to use parallel processing for the query.
+            order (Order, optional): Ordering related options. Setting `disable=True` enhances performances.
             **kwargs (Any): Additional filter criteria for the query.
 
         Returns:
             list[InfrahubNodeSync]: List of Nodes that match the given filters.
         """
-        schema = self.schema.get(kind=kind, branch=branch)
-
         branch = branch or self.default_branch
+        schema = self.schema.get(kind=kind, branch=branch)
+        node = InfrahubNodeSync(client=self, schema=schema, branch=branch)
         if at:
             at = Timestamp(at)
-
-        node = InfrahubNodeSync(client=self, schema=schema, branch=branch)
         filters = kwargs
+        pagination_size = self.pagination_size
 
-        nodes: list[InfrahubNodeSync] = []
-        related_nodes: list[InfrahubNodeSync] = []
-
-        has_remaining_items = True
-        page_number = 1
-
-        while has_remaining_items:
-            page_offset = (page_number - 1) * self.pagination_size
-
+        def process_page(page_offset: int, page_number: int) -> tuple[dict, ProcessRelationsNodeSync]:
+            """Process a single page of results."""
             query_data = InfrahubNodeSync(client=self, schema=schema, branch=branch).generate_query_data(
                 offset=offset or page_offset,
-                limit=limit or self.pagination_size,
+                limit=limit or pagination_size,
                 filters=filters,
                 include=include,
                 exclude=exclude,
@@ -1769,6 +1894,7 @@ class InfrahubClientSync(BaseClient):
                 prefetch_relationships=prefetch_relationships,
                 partial_match=partial_match,
                 property=property,
+                order=order,
             )
             query = Query(query=query_data)
             response = self.execute_graphql(
@@ -1786,14 +1912,50 @@ class InfrahubClientSync(BaseClient):
                 prefetch_relationships=prefetch_relationships,
                 timeout=timeout,
             )
-            nodes.extend(process_result["nodes"])
-            related_nodes.extend(process_result["related_nodes"])
+            return response, process_result
+
+        def process_batch() -> tuple[list[InfrahubNodeSync], list[InfrahubNodeSync]]:
+            """Process queries in parallel mode."""
+            nodes = []
+            related_nodes = []
+            batch_process = self.create_batch()
+
+            count = self.count(kind=schema.kind)
+            total_pages = (count + pagination_size - 1) // pagination_size
 
-            remaining_items = response[schema.kind].get("count", 0) - (page_offset + self.pagination_size)
-            if remaining_items < 0 or offset is not None or limit is not None:
-                has_remaining_items = False
+            for page_number in range(1, total_pages + 1):
+                page_offset = (page_number - 1) * pagination_size
+                batch_process.add(task=process_page, node=node, page_offset=page_offset, page_number=page_number)
 
-            page_number += 1
+            for _, response in batch_process.execute():
+                nodes.extend(response[1]["nodes"])
+                related_nodes.extend(response[1]["related_nodes"])
+
+            return nodes, related_nodes
+
+        def process_non_batch() -> tuple[list[InfrahubNodeSync], list[InfrahubNodeSync]]:
+            """Process queries without parallel mode."""
+            nodes = []
+            related_nodes = []
+            has_remaining_items = True
+            page_number = 1
+
+            while has_remaining_items:
+                page_offset = (page_number - 1) * pagination_size
+                response, process_result = process_page(page_offset, page_number)
+
+                nodes.extend(process_result["nodes"])
+                related_nodes.extend(process_result["related_nodes"])
+
+                remaining_items = response[schema.kind].get("count", 0) - (page_offset + pagination_size)
+                if remaining_items < 0 or offset is not None or limit is not None:
+                    has_remaining_items = False
+                page_number += 1
+
+            return nodes, related_nodes
+
+        # Select parallel or non-parallel processing
+        nodes, related_nodes = process_batch() if parallel else process_non_batch()
 
         if populate_store:
             for node in nodes:
@@ -1803,7 +1965,6 @@ class InfrahubClientSync(BaseClient):
             for node in related_nodes:
                 if node.id:
                     self.store.set(key=node.id, node=node)
-
         return nodes
 
     @overload

infrahub_sdk/ctl/cli_commands.py

@@ -4,6 +4,7 @@ import asyncio
 import functools
 import importlib
 import logging
+import platform
 import sys
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Callable
@@ -12,7 +13,11 @@ import jinja2
 import typer
 import ujson
 from rich.console import Console
+from rich.layout import Layout
 from rich.logging import RichHandler
+from rich.panel import Panel
+from rich.pretty import Pretty
+from rich.table import Table
 from rich.traceback import Traceback
 
 from .. import __version__ as sdk_version
@@ -392,11 +397,106 @@ def protocols(
 
 @app.command(name="version")
 @catch_exception(console=console)
-def version(_: str = CONFIG_PARAM) -> None:
-    """Display the version of Infrahub and the version of the Python SDK in use."""
+def version() -> None:
+    """Display the version of Python and the version of the Python SDK in use."""
 
-    client = initialize_client_sync()
-    response = client.execute_graphql(query="query { InfrahubInfo { version }}")
+    console.print(f"Python: {platform.python_version()}\nPython SDK: v{sdk_version}")
 
-    infrahub_version = response["InfrahubInfo"]["version"]
-    console.print(f"Infrahub: v{infrahub_version}\nPython SDK: v{sdk_version}")
+
+@app.command(name="info")
+@catch_exception(console=console)
+def info(detail: bool = typer.Option(False, help="Display detailed information."), _: str = CONFIG_PARAM) -> None:  # noqa: PLR0915
+    """Display the status of the Python SDK."""
+
+    info: dict[str, Any] = {
+        "error": None,
+        "status": ":x:",
+        "infrahub_version": "N/A",
+        "user_info": {},
+        "groups": {},
+    }
+    try:
+        client = initialize_client_sync()
+        info["infrahub_version"] = client.get_version()
+        info["user_info"] = client.get_user()
+        info["status"] = ":white_heavy_check_mark:"
+        info["groups"] = client.get_user_permissions()
+    except Exception as e:
+        info["error"] = f"{e!s} ({e.__class__.__name__})"
+
+    if detail:
+        layout = Layout()
+
+        # Layout structure
+        new_console = Console(height=45)
+        layout = Layout()
+        layout.split_column(
+            Layout(name="body", ratio=1),
+        )
+        layout["body"].split_row(
+            Layout(name="left"),
+            Layout(name="right"),
+        )
+
+        layout["left"].split_column(
+            Layout(name="connection_status", size=7),
+            Layout(name="client_info", ratio=1),
+        )
+
+        layout["right"].split_column(
+            Layout(name="version_info", size=7),
+            Layout(name="infrahub_info", ratio=1),
+        )
+
+        # Connection status panel
+        connection_status = Table(show_header=False, box=None)
+        connection_status.add_row("Server Address:", client.config.address)
+        connection_status.add_row("Status:", info["status"])
+        if info["error"]:
+            connection_status.add_row("Error Reason:", info["error"])
+        layout["connection_status"].update(Panel(connection_status, title="Connection Status"))
+
+        # Version information panel
+        version_info = Table(show_header=False, box=None)
+        version_info.add_row("Python Version:", platform.python_version())
+        version_info.add_row("Infrahub Version", info["infrahub_version"])
+        version_info.add_row("Infrahub SDK:", sdk_version)
+        layout["version_info"].update(Panel(version_info, title="Version Information"))
+
+        # SDK client configuration panel
+        pretty_model = Pretty(client.config.model_dump(), expand_all=True)
+        layout["client_info"].update(Panel(pretty_model, title="Client Info"))
+
+        # Infrahub information planel
+        infrahub_info = Table(show_header=False, box=None)
+        if info["user_info"]:
+            infrahub_info.add_row("User:", info["user_info"]["AccountProfile"]["display_label"])
+            infrahub_info.add_row("Description:", info["user_info"]["AccountProfile"]["description"]["value"])
+            infrahub_info.add_row("Status:", info["user_info"]["AccountProfile"]["status"]["label"])
+            infrahub_info.add_row(
+                "Number of Groups:", str(info["user_info"]["AccountProfile"]["member_of_groups"]["count"])
+            )
+
+            if groups := info["groups"]:
+                infrahub_info.add_row("Groups:", "")
+                for group, roles in groups.items():
+                    infrahub_info.add_row("", group, ", ".join(roles))
+
+        layout["infrahub_info"].update(Panel(infrahub_info, title="Infrahub Info"))
+
+        new_console.print(layout)
+    else:
+        # Simple output
+        table = Table(show_header=False, box=None)
+        table.add_row("Address:", client.config.address)
+        table.add_row("Connection Status:", info["status"])
+        if info["error"]:
+            table.add_row("Connection Error:", info["error"])
+
+        table.add_row("Python Version:", platform.python_version())
+        table.add_row("SDK Version:", sdk_version)
+        table.add_row("Infrahub Version:", info["infrahub_version"])
+        if account := info["user_info"].get("AccountProfile"):
+            table.add_row("User:", account["display_label"])
+
+        console.print(table)

infrahub_sdk/data.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from .node import InfrahubNode  # noqa: TCH001
+from .node import InfrahubNode  # noqa: TC001
 
 
 class RepositoryBranchInfo(BaseModel):
@@ -13,7 +13,8 @@ class RepositoryData(BaseModel):
     model_config = ConfigDict(arbitrary_types_allowed=True)
     repository: InfrahubNode = Field(..., description="InfrahubNode representing a Repository")
     branches: dict[str, str] = Field(
-        ..., description="Dictionary with the name of the branch as the key and the active commit id as the value"
+        ...,
+        description="Dictionary with the name of the branch as the key and the active commit id as the value",
     )
 
     branch_info: dict[str, RepositoryBranchInfo] = Field(default_factory=dict)

infrahub_sdk/graphql.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import Any
 
+from pydantic import BaseModel
+
 VARIABLE_TYPE_MAPPING = ((str, "String!"), (int, "Int!"), (float, "Float!"), (bool, "Boolean!"))
 
 
@@ -15,6 +17,9 @@ def convert_to_graphql_as_string(value: str | bool | list) -> str:
     if isinstance(value, list):
         values_as_string = [convert_to_graphql_as_string(item) for item in value]
         return "[" + ", ".join(values_as_string) + "]"
+    if isinstance(value, BaseModel):
+        data = value.model_dump()
+        return "{ " + ", ".join(f"{key}: {convert_to_graphql_as_string(val)}" for key, val in data.items()) + " }"
 
     return str(value)