infrahub-server 1.4.10__py3-none-any.whl → 1.5.0b1__py3-none-any.whl

infrahub/hfid/tasks.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+from typing import cast
+
+from prefect import flow
+from prefect.logging import get_run_logger
+
+from infrahub.context import InfrahubContext  # noqa: TC001  needed for prefect flow
+from infrahub.core.registry import registry
+from infrahub.events import BranchDeletedEvent
+from infrahub.trigger.models import TriggerSetupReport, TriggerType
+from infrahub.trigger.setup import setup_triggers_specific
+from infrahub.workers.dependencies import get_client, get_component, get_database, get_workflow
+from infrahub.workflows.catalogue import HFID_PROCESS, TRIGGER_UPDATE_HFID
+from infrahub.workflows.utils import add_tags, wait_for_schema_to_converge
+
+from .gather import gather_trigger_hfid
+from .models import HFIDGraphQL, HFIDGraphQLResponse, HFIDTriggerDefinition
+
+UPDATE_HFID = """
+mutation UpdateHFID(
+    $id: String!,
+    $kind: String!,
+    $value: [String!]!
+  ) {
+  InfrahubUpdateHFID(
+    data: {id: $id, value: $value, kind: $kind}
+  ) {
+    ok
+  }
+}
+"""
+
+
+@flow(
+    name="hfid-update-value",
+    flow_run_name="Update value for hfid on {node_kind}",
+)
+async def hfid_update_value(
+    branch_name: str,
+    obj: HFIDGraphQLResponse,
+    node_kind: str,
+    hfid_definition: list[str],
+) -> None:
+    log = get_run_logger()
+    client = get_client()
+
+    await add_tags(branches=[branch_name], nodes=[obj.node_id], db_change=True)
+
+    rendered_hfid: list[str] = []
+    for hfid_component in hfid_definition:
+        if hfid_component in obj.variables:
+            rendered_hfid.append(obj.variables[hfid_component])
+    # value = await template.render(variables=obj.variables)
+    if rendered_hfid == obj.hfid_value:
+        log.debug(f"Ignoring to update {obj} with existing value on human_friendly_id={obj.hfid_value}")
+        return
+
+    await client.execute_graphql(
+        query=UPDATE_HFID,
+        variables={"id": obj.node_id, "kind": node_kind, "value": rendered_hfid},
+        branch_name=branch_name,
+    )
+    log.info(f"Updating {node_kind}.human_friendly_id='{rendered_hfid}' ({obj.node_id})")
+
+
+@flow(
+    name="hfid-process",
+    flow_run_name="Process human friendly ids for {target_kind}",
+)
+async def process_hfid(
+    branch_name: str,
+    node_kind: str,
+    object_id: str,
+    target_kind: str,
+    context: InfrahubContext,  # noqa: ARG001
+) -> None:
+    log = get_run_logger()
+    client = get_client()
+
+    await add_tags(branches=[branch_name])
+
+    target_schema = branch_name if branch_name in registry.get_altered_schema_branches() else registry.default_branch
+    schema_branch = registry.schema.get_schema_branch(name=target_schema)
+    node_schema = schema_branch.get_node(name=target_kind, duplicate=False)
+
+    if node_kind == target_kind:
+        hfid_definition = schema_branch.hfids.get_node_definition(kind=node_kind)
+    else:
+        hfid_definition = schema_branch.hfids.get_related_definition(related_kind=node_kind, target_kind=target_kind)
+
+    # jinja_template = Jinja2Template(template=display_label_template.template)
+    # variables = jinja_template.get_variables()
+    hfid_graphql = HFIDGraphQL(
+        node_schema=node_schema, variables=hfid_definition.hfid, filter_key=hfid_definition.filter_key
+    )
+
+    query = hfid_graphql.render_graphql_query(filter_id=object_id)
+    response = await client.execute_graphql(query=query, branch_name=branch_name)
+    update_candidates = hfid_graphql.parse_response(response=response)
+
+    if not update_candidates:
+        log.debug("No nodes found that requires updates")
+        return
+
+    batch = await client.create_batch()
+    for node in update_candidates:
+        batch.add(
+            task=hfid_update_value,
+            branch_name=branch_name,
+            obj=node,
+            node_kind=node_schema.kind,
+            hfid_definition=hfid_definition.hfid,
+        )
+
+    _ = [response async for _, response in batch.execute()]
+
+
+@flow(name="hfid-setup", flow_run_name="Setup human friendly ids in task-manager")
+async def hfid_setup(context: InfrahubContext, branch_name: str | None = None, event_name: str | None = None) -> None:
+    database = await get_database()
+    async with database.start_session() as db:
+        log = get_run_logger()
+
+        if branch_name:
+            await add_tags(branches=[branch_name])
+            component = await get_component()
+            await wait_for_schema_to_converge(branch_name=branch_name, component=component, db=db, log=log)
+
+        report: TriggerSetupReport = await setup_triggers_specific(
+            gatherer=gather_trigger_hfid, trigger_type=TriggerType.HUMAN_FRIENDLY_ID
+        )  # type: ignore[misc]
+
+        # Configure all DisplayLabelTriggerDefinitions in Prefect
+        hfid_reports = [cast(HFIDTriggerDefinition, entry) for entry in report.updated + report.created]
+        direct_target_triggers = [hfid_report for hfid_report in hfid_reports if hfid_report.target_kind]
+
+        for display_report in direct_target_triggers:
+            if event_name != BranchDeletedEvent.event_name and display_report.branch == branch_name:
+                await get_workflow().submit_workflow(
+                    workflow=TRIGGER_UPDATE_HFID,
+                    context=context,
+                    parameters={
+                        "branch_name": display_report.branch,
+                        "kind": display_report.target_kind,
+                    },
+                )
+
+        log.info(f"{report.in_use_count} HFID automation configurations completed")
+
+
+@flow(
+    name="trigger-update-hfid",
+    flow_run_name="Trigger updates for display labels for kind",
+)
+async def trigger_update_hfid(
+    branch_name: str,
+    kind: str,
+    context: InfrahubContext,
+) -> None:
+    await add_tags(branches=[branch_name])
+
+    client = get_client()
+
+    # NOTE we only need the id of the nodes, this query will still query for the HFID
+    node_schema = registry.schema.get_node_schema(name=kind, branch=branch_name)
+    nodes = await client.all(
+        kind=kind,
+        branch=branch_name,
+        exclude=node_schema.attribute_names + node_schema.relationship_names,
+        populate_store=False,
+    )
+
+    for node in nodes:
+        await get_workflow().submit_workflow(
+            workflow=HFID_PROCESS,
+            context=context,
+            parameters={
+                "branch_name": branch_name,
+                "node_kind": kind,
+                "target_kind": kind,
+                "object_id": node.id,
+                "context": context,
+            },
+        )

infrahub/hfid/triggers.py

@@ -0,0 +1,22 @@
+from infrahub.events.branch_action import BranchDeletedEvent
+from infrahub.events.schema_action import SchemaUpdatedEvent
+from infrahub.trigger.models import BuiltinTriggerDefinition, EventTrigger, ExecuteWorkflow
+from infrahub.workflows.catalogue import HFID_SETUP
+
+TRIGGER_HFID_ALL_SCHEMA = BuiltinTriggerDefinition(
+    name="hfid-setup-all",
+    trigger=EventTrigger(events={SchemaUpdatedEvent.event_name, BranchDeletedEvent.event_name}),
+    actions=[
+        ExecuteWorkflow(
+            workflow=HFID_SETUP,
+            parameters={
+                "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
+                "event_name": "{{ event.event }}",
+                "context": {
+                    "__prefect_kind": "json",
+                    "value": {"__prefect_kind": "jinja", "template": "{{ event.payload['context'] | tojson }}"},
+                },
+            },
+        ),
+    ],
+)

infrahub/lock.py

@@ -25,6 +25,7 @@ registry: InfrahubLockRegistry = None
 
 
 METRIC_PREFIX = "infrahub_lock"
+LOCK_PREFIX = "lock"
 
 LOCK_ACQUIRE_TIME_METRICS = Histogram(
     f"{METRIC_PREFIX}_acquire_seconds",
@@ -97,10 +98,10 @@ class NATSLock:
         while True:
             if await self.do_acquire(token):
                 self.token = token
-                return True
+                return
             await sleep(0.1)  # default Redis GlobalLock value
 
-    async def do_acquire(self, token: str) -> bool:
+    async def do_acquire(self, token: str) -> bool | None:
         return await self.service.cache.set(key=self.name, value=token, not_exists=True)
 
     async def release(self) -> None:
@@ -123,14 +124,14 @@ class InfrahubLock:
         local: bool | None = None,
         in_multi: bool = False,
     ) -> None:
-        self.use_local: bool = local
+        self.use_local: bool | None = local
         self.local: LocalLock = None
         self.remote: GlobalLock = None
         self.name: str = name
         self.connection: redis.Redis | None = connection
         self.in_multi: bool = in_multi
         self.lock_type: str = "multi" if self.in_multi else "individual"
-        self.acquire_time: int | None = None
+        self._acquire_time: int | None = None
         self.event = asyncio.Event()
 
         if not self.connection or (self.use_local is None and name.startswith("local.")):
@@ -139,9 +140,20 @@ class InfrahubLock:
         if self.use_local:
             self.local = LocalLock()
         elif config.SETTINGS.cache.driver == config.CacheDriver.Redis:
-            self.remote = GlobalLock(redis=self.connection, name=f"lock.{self.name}")
+            self.remote = GlobalLock(redis=self.connection, name=f"{LOCK_PREFIX}.{self.name}")
         else:
-            self.remote = NATSLock(service=self.connection, name=f"lock.{self.name}")
+            self.remote = NATSLock(service=self.connection, name=f"{LOCK_PREFIX}.{self.name}")
+
+    @property
+    def acquire_time(self) -> int:
+        if self._acquire_time is not None:
+            return self._acquire_time
+
+        raise ValueError("The lock has not been initialized")
+
+    @acquire_time.setter
+    def acquire_time(self, value: int) -> None:
+        self._acquire_time = value
 
     async def __aenter__(self):
         await self.acquire()
@@ -179,9 +191,54 @@ class InfrahubLock:
         return self.local.locked()
 
 
+class LockNameGenerator:
+    local = "local"
+    _global = "global"
+
+    def generate_name(self, name: str, namespace: str | None = None, local: bool | None = None) -> str:
+        if namespace is None and local is None:
+            return name
+
+        new_name = ""
+        if local is True:
+            new_name = f"{self.local}."
+        elif local is False:
+            new_name = f"{self._global}."
+
+        if namespace is not None:
+            new_name += f"{namespace}."
+        new_name += name
+
+        return new_name
+
+    def unpack_name(self, name: str) -> tuple[str, str | None, bool | None]:
+        local = None
+        namespace = None
+
+        parts = name.split(".")
+        if parts[0] == self.local:
+            local = True
+            parts = parts[1:]
+        elif parts[0] == self._global:
+            local = False
+            parts = parts[1:]
+
+        if len(parts) > 1:
+            namespace = parts[0]
+            original_name = ".".join(parts[1:])
+        else:
+            original_name = parts[0]
+
+        return original_name, namespace, local
+
+
 class InfrahubLockRegistry:
     def __init__(
-        self, token: str | None = None, local_only: bool = False, service: InfrahubServices | None = None
+        self,
+        token: str | None = None,
+        local_only: bool = False,
+        service: InfrahubServices | None = None,
+        name_generator: LockNameGenerator | None = None,
     ) -> None:
         if config.SETTINGS.cache.enable and not local_only:
             if config.SETTINGS.cache.driver == config.CacheDriver.Redis:
@@ -201,23 +258,7 @@ class InfrahubLockRegistry:
 
         self.token = token or str(uuid.uuid4())
         self.locks: dict[str, InfrahubLock] = {}
-
-    @classmethod
-    def _generate_name(cls, name: str, namespace: str | None = None, local: bool | None = None) -> str:
-        if namespace is None and local is None:
-            return name
-
-        new_name = ""
-        if local is True:
-            new_name = "local."
-        elif local is False:
-            new_name = "global."
-
-        if namespace is not None:
-            new_name += f"{namespace}."
-        new_name += name
-
-        return new_name
+        self.name_generator = name_generator or LockNameGenerator()
 
     def get_existing(
         self,
@@ -225,7 +266,7 @@ class InfrahubLockRegistry:
         namespace: str | None,
         local: bool | None = None,
     ) -> InfrahubLock | None:
-        lock_name = self._generate_name(name=name, namespace=namespace, local=local)
+        lock_name = self.name_generator.generate_name(name=name, namespace=namespace, local=local)
         if lock_name not in self.locks:
             return None
         return self.locks[lock_name]
@@ -233,7 +274,7 @@ class InfrahubLockRegistry:
     def get(
         self, name: str, namespace: str | None = None, local: bool | None = None, in_multi: bool = False
     ) -> InfrahubLock:
-        lock_name = self._generate_name(name=name, namespace=namespace, local=local)
+        lock_name = self.name_generator.generate_name(name=name, namespace=namespace, local=local)
         if lock_name not in self.locks:
             self.locks[lock_name] = InfrahubLock(name=lock_name, connection=self.connection, in_multi=in_multi)
         return self.locks[lock_name]
@@ -257,7 +298,3 @@ class InfrahubLockRegistry:
 def initialize_lock(local_only: bool = False, service: InfrahubServices | None = None) -> None:
     global registry
     registry = InfrahubLockRegistry(local_only=local_only, service=service)
-
-
-def build_object_lock_name(name: str) -> str:
-    return f"global.object.{name}"

infrahub/locks/tasks.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from prefect import flow
+from prefect.logging import get_run_logger
+
+from infrahub import config
+from infrahub.core.registry import registry
+from infrahub.core.timestamp import Timestamp
+from infrahub.lock import LOCK_PREFIX
+from infrahub.services import InfrahubServices  # noqa: TC001  needed for prefect flow
+
+
+@flow(
+    name="clean-up-deadlocks",
+    flow_run_name="Clean up deadlocks",
+)
+async def clean_up_deadlocks(service: InfrahubServices) -> None:
+    """Remove stale distributed locks left behind by inactive workers"""
+    keys = await service.cache.list_keys(filter_pattern=f"{LOCK_PREFIX}*")
+    if not keys:
+        return
+
+    log = get_run_logger()
+    values = await service.cache.get_values(keys=keys)
+    workers = await service.component.list_workers(branch=registry.default_branch, schema_hash=False)
+    workers_active = {worker.id for worker in workers if worker.active}
+
+    for key, value in zip(keys, values, strict=False):
+        if not key or not value:
+            continue
+
+        timestamp, worker_id = value.split("::", 1)
+        if worker_id not in workers_active and Timestamp() > Timestamp(timestamp).add(
+            minutes=config.SETTINGS.cache.clean_up_deadlocks_interval_mins
+        ):
+            await service.cache.delete(key)
+            log.info(f"Deleted deadlock key={key} worker={worker_id}")

infrahub/middleware.py

@@ -1,7 +1,8 @@
 from typing import Any
 
+from fastapi.middleware.gzip import GZipMiddleware
 from starlette.middleware.cors import CORSMiddleware
-from starlette.types import ASGIApp
+from starlette.types import ASGIApp, Receive, Scope, Send
 
 from infrahub import config
 
@@ -15,3 +16,27 @@ class InfrahubCORSMiddleware(CORSMiddleware):
         kwargs["allow_headers"] = config.SETTINGS.api.cors_allow_headers
 
         super().__init__(app, *args, **kwargs)
+
+
+class ConditionalGZipMiddleware(GZipMiddleware):
+    def __init__(
+        self,
+        app: ASGIApp,
+        *,
+        minimum_size: int = 500,
+        compresslevel: int = 9,
+        include_paths: tuple[str, ...] = (),
+    ) -> None:
+        super().__init__(app, minimum_size=minimum_size, compresslevel=compresslevel)
+        self.include_paths = include_paths
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:  # type: ignore[override]
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        path = scope.get("path", "")
+        if any(path.startswith(include) for include in self.include_paths):
+            await super().__call__(scope, receive, send)
+        else:
+            await self.app(scope, receive, send)

infrahub/patch/plan_writer.py

@@ -1,6 +1,6 @@
 import json
 from dataclasses import asdict
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
 from typing import Any
 
@@ -10,7 +10,7 @@ from .models import EdgeToAdd, EdgeToDelete, EdgeToUpdate, PatchPlan, VertexToAd
 
 class PatchPlanWriter:
     def write(self, patches_directory: Path, patch_plan: PatchPlan) -> Path:
-        timestamp_str = datetime.now(tz=timezone.utc).strftime("%Y%m%d-%H%M%S")
+        timestamp_str = datetime.now(tz=UTC).strftime("%Y%m%d-%H%M%S")
         patch_name = f"patch-{patch_plan.name}-{timestamp_str}"
         patch_plan_directory = patches_directory / Path(patch_name)
         if not patch_plan_directory.exists():

infrahub/profiles/node_applier.py

@@ -0,0 +1,101 @@
+from typing import Any
+
+from infrahub.core.attribute import BaseAttribute
+from infrahub.core.branch import Branch
+from infrahub.core.node import Node
+from infrahub.database import InfrahubDatabase
+
+from .queries.get_profile_data import GetProfileDataQuery, ProfileData
+
+
+class NodeProfilesApplier:
+    def __init__(self, db: InfrahubDatabase, branch: Branch):
+        self.db = db
+        self.branch = branch
+
+    async def _get_profile_ids(self, node: Node) -> list[str]:
+        try:
+            profiles_rel = node.get_relationship("profiles")
+        except ValueError:
+            return []
+        profile_rels = await profiles_rel.get_relationships(db=self.db)
+        return [pr.peer_id for pr in profile_rels if pr.peer_id]
+
+    async def _get_attr_names_for_profiles(self, node: Node) -> list[str]:
+        node_schema = node.get_schema()
+
+        # get the names of attributes that could be affected by profile changes
+        attr_names_for_profiles: list[str] = []
+        for attr_schema in node_schema.attributes:
+            attr_name = attr_schema.name
+            node_attr: BaseAttribute = getattr(node, attr_name)
+            if node_attr.is_from_profile or node_attr.is_default:
+                attr_names_for_profiles.append(attr_name)
+        return attr_names_for_profiles
+
+    async def _get_sorted_profile_data(
+        self, profile_ids: list[str], attr_names_for_profiles: list[str]
+    ) -> list[ProfileData]:
+        if not profile_ids:
+            return []
+        query = await GetProfileDataQuery.init(
+            db=self.db, branch=self.branch, profile_ids=profile_ids, attr_names=attr_names_for_profiles
+        )
+        await query.execute(db=self.db)
+        profile_data_list = query.get_profile_data()
+        return sorted(profile_data_list, key=lambda x: (x.priority, x.uuid))
+
+    def _apply_profile_to_attribute(self, node_attr: BaseAttribute, profile_value: Any, profile_id: str) -> bool:
+        is_changed = False
+        if node_attr.value != profile_value:
+            node_attr.value = profile_value
+            is_changed = True
+        if node_attr.is_default is not False:
+            node_attr.is_default = False
+            is_changed = True
+        if node_attr.is_from_profile is not True:
+            node_attr.is_from_profile = True
+            is_changed = True
+        if node_attr.source_id != profile_id:  # type: ignore[attr-defined]
+            node_attr.set_source(value=profile_id)
+            is_changed = True
+        return is_changed
+
+    def _remove_profile_from_attribute(self, node_attr: BaseAttribute) -> None:
+        node_attr.clear_source()
+        node_attr.value = node_attr.schema.default_value
+        node_attr.is_default = True
+        node_attr.is_from_profile = False
+
+    async def apply_profiles(self, node: Node) -> list[str]:
+        profile_ids = await self._get_profile_ids(node=node)
+        attr_names_for_profiles = await self._get_attr_names_for_profiles(node=node)
+
+        if not attr_names_for_profiles:
+            return []
+
+        # get profiles priorities and attribute values on branch
+        sorted_profile_data = await self._get_sorted_profile_data(
+            profile_ids=profile_ids, attr_names_for_profiles=attr_names_for_profiles
+        )
+
+        updated_field_names = []
+        # set attribute values/is_default/is_from_profile on nodes
+        for attr_name in attr_names_for_profiles:
+            has_profile_data = False
+            node_attr = node.get_attribute(attr_name)
+            for profile_data in sorted_profile_data:
+                profile_value = profile_data.attribute_values.get(attr_name)
+                if profile_value is not None:
+                    has_profile_data = True
+                    is_changed = False
+                    is_changed = self._apply_profile_to_attribute(
+                        node_attr=node_attr, profile_value=profile_value, profile_id=profile_data.uuid
+                    )
+                    if is_changed:
+                        updated_field_names.append(attr_name)
+                    break
+            if not has_profile_data and node_attr.is_from_profile:
+                self._remove_profile_from_attribute(node_attr=node_attr)
+                updated_field_names.append(attr_name)
+        return updated_field_names

infrahub/profiles/queries/get_profile_data.py

@@ -0,0 +1,99 @@
+from dataclasses import dataclass
+from typing import Any
+
+from infrahub.core.constants import NULL_VALUE
+from infrahub.core.query import Query, QueryType
+from infrahub.database import InfrahubDatabase
+
+
+@dataclass
+class ProfileData:
+    uuid: str
+    priority: float | int
+    attribute_values: dict[str, Any]
+
+
+class GetProfileDataQuery(Query):
+    type: QueryType = QueryType.READ
+    insert_return: bool = False
+
+    def __init__(self, *args: Any, profile_ids: list[str], attr_names: list[str], **kwargs: Any):
+        super().__init__(*args, **kwargs)
+        self.profile_ids = profile_ids
+        self.attr_names = attr_names
+
+    async def query_init(self, db: InfrahubDatabase, **kwargs: dict[str, Any]) -> None:  # noqa: ARG002
+        branch_filter, branch_params = self.branch.get_query_filter_path(at=self.at.to_string())
+        self.params.update(branch_params)
+        self.params["profile_ids"] = self.profile_ids
+        self.params["attr_names"] = self.attr_names + ["profile_priority"]
+
+        query = """
+// --------------
+// get the Profile nodes
+// --------------
+MATCH (profile:Node)
+WHERE profile.uuid IN $profile_ids
+// --------------
+// make sure we only use the active ones
+// --------------
+CALL (profile) {
+    MATCH (profile)-[r:IS_PART_OF]->(:Root)
+    WHERE %(branch_filter)s
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    RETURN r.status = "active" AS is_active
+}
+WITH profile
+WHERE is_active = TRUE
+// --------------
+// get the attributes that we care about
+// --------------
+MATCH (profile)-[:HAS_ATTRIBUTE]-(attr:Attribute)
+WHERE attr.name IN $attr_names
+WITH DISTINCT profile, attr
+CALL (profile, attr) {
+    MATCH (profile)-[r:HAS_ATTRIBUTE]->(attr)
+    WHERE %(branch_filter)s
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    RETURN r.status = "active" AS is_active
+}
+WITH profile, attr, is_active
+WHERE is_active = TRUE
+// --------------
+// get the attribute values
+// --------------
+MATCH (attr)-[:HAS_VALUE]->(av:AttributeValue)
+WITH DISTINCT profile, attr, av
+CALL (attr, av) {
+    MATCH (attr)-[r:HAS_VALUE]->(av)
+    WHERE %(branch_filter)s
+    ORDER BY r.branch_level DESC, r.from DESC, r.status ASC
+    RETURN r.status = "active" AS is_active
+}
+WITH profile, attr, av
+WHERE is_active = TRUE
+RETURN profile.uuid AS profile_uuid, attr.name AS attr_name, av.value AS attr_value
+        """ % {"branch_filter": branch_filter}
+        self.add_to_query(query)
+        self.return_labels = ["profile_uuid", "attr_name", "attr_value"]
+
+    def get_profile_data(self) -> list[ProfileData]:
+        profile_data_by_uuid: dict[str, ProfileData] = {}
+        for result in self.results:
+            profile_uuid = result.get_as_type(label="profile_uuid", return_type=str)
+            if profile_uuid not in profile_data_by_uuid:
+                profile_data_by_uuid[profile_uuid] = ProfileData(
+                    uuid=profile_uuid, priority=float("inf"), attribute_values={}
+                )
+            profile_data = profile_data_by_uuid[profile_uuid]
+            attr_name = result.get_as_type(label="attr_name", return_type=str)
+            attr_value: Any = result.get(label="attr_value")
+            if attr_value == NULL_VALUE:
+                attr_value = None
+            if attr_name == "profile_priority":
+                if attr_value is not None and not isinstance(attr_value, int):
+                    attr_value = int(attr_value)
+                profile_data.priority = attr_value
+            else:
+                profile_data.attribute_values[attr_name] = attr_value
+        return list(profile_data_by_uuid.values())