port-ocean 0.21.5__py3-none-any.whl → 0.22.1__py3-none-any.whl

integrations/_infra/Makefile

@@ -11,6 +11,8 @@ define run_checks
 	ruff check . || exit_code=$$?; \
 	echo "Running black"; \
 	black --check . || exit_code=$$?; \
+	echo "Running yamllint"; \
+	yamllint . || exit_code=$$?; \
 	if [ $$exit_code -eq 1 ]; then \
 		echo "\033[0;31mOne or more checks failed with exit code $$exit_code\033[0m"; \
 	else \

port_ocean/cli/cookiecutter/cookiecutter.json

@@ -6,8 +6,8 @@
     "email": "Your address email <you@example.com>",
     "release_date": "{% now 'local' %}",
     "is_private_integration": true,
-    "port_client_id": "you can find it using: https://docs.getport.io/build-your-software-catalog/custom-integration/api/#find-your-port-credentials",
-    "port_client_secret": "you can find it using: https://docs.getport.io/build-your-software-catalog/custom-integration/api/#find-your-port-credentials",
+    "port_client_id": "you can find it using: https://docs.port.io/build-your-software-catalog/custom-integration/api/#find-your-port-credentials",
+    "port_client_secret": "you can find it using: https://docs.port.io/build-your-software-catalog/custom-integration/api/#find-your-port-credentials",
     "is_us_region": false,
     "_extensions": [
         "jinja2_time.TimeExtension",

port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/README.md

@@ -2,6 +2,6 @@
 
 An integration used to import {{cookiecutter.integration_name}} resources into Port.
 
-#### Install & use the integration - [Integration documentation](https://docs.getport.io/build-your-software-catalog/sync-data-to-catalog/) *Replace this link with a link to this integration's documentation*
+#### Install & use the integration - [Integration documentation](https://docs.port.io/build-your-software-catalog/sync-data-to-catalog/) *Replace this link with a link to this integration's documentation*
 
 #### Develop & improve the integration - [Ocean integration development documentation](https://ocean.getport.io/develop-an-integration/)

port_ocean/clients/port/mixins/entities.py

@@ -2,6 +2,7 @@ import asyncio
 from typing import Any, Literal
 from urllib.parse import quote_plus
 
+
 import httpx
 from loguru import logger
 
@@ -99,7 +100,6 @@ class EntityClientMixin:
         # We return None to ignore the entity later in the delete process
         if result_entity.is_using_search_identifier:
             return None
-
         return self._reduce_entity(result_entity)
 
     @staticmethod
@@ -125,7 +125,6 @@ class EntityClientMixin:
             key: None if isinstance(relation, dict) else relation
             for key, relation in entity.relations.items()
         }
-
         return reduced_entity
 
     async def batch_upsert_entities(
@@ -134,7 +133,7 @@ class EntityClientMixin:
         request_options: RequestOptions,
         user_agent_type: UserAgentType | None = None,
         should_raise: bool = True,
-    ) -> list[Entity]:
+    ) -> list[tuple[bool, Entity]]:
         modified_entities_results = await asyncio.gather(
             *(
                 self.upsert_entity(
@@ -147,17 +146,17 @@ class EntityClientMixin:
             ),
             return_exceptions=True,
         )
-        entity_results = [
-            entity for entity in modified_entities_results if isinstance(entity, Entity)
-        ]
-        if not should_raise:
-            return entity_results
 
-        for entity_result in modified_entities_results:
-            if isinstance(entity_result, Exception):
-                raise entity_result
+        entities_results: list[tuple[bool, Entity]] = []
+        for original_entity, result in zip(entities, modified_entities_results):
+            if isinstance(result, Exception) and should_raise:
+                raise result
+            elif isinstance(result, Entity):
+                entities_results.append((True, result))
+            elif result is False:
+                entities_results.append((False, original_entity))
 
-        return entity_results
+        return entities_results
 
     async def delete_entity(
         self,

port_ocean/config/settings.py

@@ -61,6 +61,11 @@ class IntegrationSettings(BaseOceanModel, extra=Extra.allow):
         return values
 
 
+class MetricsSettings(BaseOceanModel, extra=Extra.allow):
+    enabled: bool = Field(default=False)
+    webhook_url: str | None = Field(default=None)
+
+
 class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     _integration_config_model: BaseModel | None = None
 
@@ -83,9 +88,26 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     )
     runtime: Runtime = Runtime.OnPrem
     resources_path: str = Field(default=".port/resources")
+    metrics: MetricsSettings = Field(
+        default_factory=lambda: MetricsSettings(enabled=False, webhook_url=None)
+    )
     max_event_processing_seconds: float = 90.0
     max_wait_seconds_before_shutdown: float = 5.0
 
+    @validator("metrics", pre=True)
+    def validate_metrics(cls, v: Any) -> MetricsSettings | dict[str, Any] | None:
+        if v is None:
+            return MetricsSettings(enabled=False, webhook_url=None)
+        if isinstance(v, dict):
+            return v
+        if isinstance(v, MetricsSettings):
+            return v
+        # Try to convert to dict for other types
+        try:
+            return dict(v)
+        except (TypeError, ValueError):
+            return MetricsSettings(enabled=False, webhook_url=None)
+
     @root_validator()
     def validate_integration_config(cls, values: dict[str, Any]) -> dict[str, Any]:
         if not (config_model := values.get("_integration_config_model")):

port_ocean/context/event.py

@@ -142,6 +142,7 @@ async def event_context(
     )
 
     attributes = {**parent_attributes, **(attributes or {})}
+
     new_event = EventContext(
         event_type,
         trigger_type=trigger_type,

port_ocean/context/ocean.py

@@ -1,6 +1,7 @@
 from typing import Callable, TYPE_CHECKING, Any, Literal, Union
 
 from fastapi import APIRouter
+from port_ocean.helpers.metric.metric import Metrics
 from pydantic.main import BaseModel
 from werkzeug.local import LocalProxy
 
@@ -41,6 +42,10 @@ class PortOceanContext:
             )
         return self._app
 
+    @property
+    def metrics(self) -> Metrics:
+        return self.app.metrics
+
     @property
     def initialized(self) -> bool:
         return self._app is not None

port_ocean/context/resource.py

@@ -23,6 +23,7 @@ class ResourceContext:
     """
 
     resource_config: "ResourceConfig"
+    index: int
 
     @property
     def kind(self) -> str:
@@ -50,12 +51,10 @@ resource: ResourceContext = LocalProxy(lambda: _get_resource_context())  # type:
 
 @asynccontextmanager
 async def resource_context(
-    resource_config: "ResourceConfig",
+    resource_config: "ResourceConfig", index: int = 0
 ) -> AsyncIterator[ResourceContext]:
     _resource_context_stack.push(
-        ResourceContext(
-            resource_config=resource_config,
-        )
+        ResourceContext(resource_config=resource_config, index=index)
     )
 
     with logger.contextualize(resource_kind=resource.kind):

port_ocean/core/defaults/common.py

@@ -68,6 +68,7 @@ def deconstruct_blueprints_to_creation_steps(
         with_relations.append(blueprint.copy())
 
         blueprint.pop("teamInheritance", {})
+        blueprint.pop("ownership", {})
         blueprint.pop("relations", {})
         bare_blueprint.append(blueprint)
 

port_ocean/core/defaults/initialize.py

@@ -42,8 +42,8 @@ def deconstruct_blueprints_to_creation_steps(
         blueprint.pop("mirrorProperties", {})
         blueprint.pop("aggregationProperties", {})
         with_relations.append(blueprint.copy())
-
         blueprint.pop("teamInheritance", {})
+        blueprint.pop("ownership", {})
         blueprint.pop("relations", {})
         bare_blueprint.append(blueprint)
 

port_ocean/core/event_listener/base.py

@@ -14,7 +14,7 @@ class EventListenerEvents(TypedDict):
     A dictionary containing event types and their corresponding event handlers.
     """
 
-    on_resync: Callable[[dict[Any, Any]], Awaitable[None]]
+    on_resync: Callable[[dict[Any, Any]], Awaitable[bool]]
 
 
 class BaseEventListener:
@@ -67,8 +67,11 @@ class BaseEventListener:
         """
         await self._before_resync()
         try:
-            await self.events["on_resync"](resync_args)
-            await self._after_resync()
+            resync_succeeded = await self.events["on_resync"](resync_args)
+            if resync_succeeded:
+                await self._after_resync()
+            else:
+                await self._on_resync_failure(Exception("Resync failed"))
         except Exception as e:
             await self._on_resync_failure(e)
             raise e

port_ocean/core/handlers/entities_state_applier/port/applier.py

@@ -8,7 +8,9 @@ from port_ocean.core.handlers.entities_state_applier.base import (
 from port_ocean.core.handlers.entities_state_applier.port.get_related_entities import (
     get_related_entities,
 )
-
+from port_ocean.context.ocean import ocean
+from port_ocean.helpers.metric.metric import MetricType, MetricPhase
+from port_ocean.helpers.metric.utils import TimeMetric
 from port_ocean.core.models import Entity
 from port_ocean.core.ocean_types import EntityDiff
 from port_ocean.core.utils.entity_topological_sorter import EntityTopologicalSorter
@@ -23,6 +25,7 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
     through HTTP requests.
     """
 
+    @TimeMetric(MetricPhase.DELETE)
     async def _safe_delete(
         self,
         entities_to_delete: list[Entity],
@@ -100,6 +103,11 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
             and deletion_rate <= entity_deletion_threshold
         ):
             await self._safe_delete(diff.deleted, kept_entities, user_agent_type)
+            ocean.metrics.set_metric(
+                name=MetricType.DELETION_COUNT_NAME,
+                labels=[ocean.metrics.current_resource_kind(), MetricPhase.DELETE],
+                value=len(diff.deleted),
+            )
         else:
             logger.info(
                 f"Skipping deletion of entities with deletion rate {deletion_rate}",
@@ -113,26 +121,20 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
     ) -> list[Entity]:
         logger.info(f"Upserting {len(entities)} entities")
         modified_entities: list[Entity] = []
-        if event.port_app_config.create_missing_related_entities:
-            modified_entities = await self.context.port_client.batch_upsert_entities(
-                entities,
-                event.port_app_config.get_port_request_options(),
-                user_agent_type,
-                should_raise=False,
-            )
-        else:
-            for entity in entities:
-                upsertedEntity = await self.context.port_client.upsert_entity(
-                    entity,
-                    event.port_app_config.get_port_request_options(),
-                    user_agent_type,
-                    should_raise=False,
-                )
-                if upsertedEntity:
-                    modified_entities.append(upsertedEntity)
-                # condition to false to differentiate from `result_entity.is_using_search_identifier`
-                if upsertedEntity is False:
-                    event.entity_topological_sorter.register_entity(entity)
+        upserted_entities: list[tuple[bool, Entity]] = []
+
+        upserted_entities = await self.context.port_client.batch_upsert_entities(
+            entities,
+            event.port_app_config.get_port_request_options(),
+            user_agent_type,
+            should_raise=False,
+        )
+
+        for is_upserted, entity in upserted_entities:
+            if is_upserted:
+                modified_entities.append(entity)
+            else:
+                event.entity_topological_sorter.register_entity(entity)
         return modified_entities
 
     async def delete(

port_ocean/core/handlers/entity_processor/base.py

@@ -1,7 +1,6 @@
 from abc import abstractmethod
 
 from loguru import logger
-
 from port_ocean.core.handlers.base import BaseHandler
 from port_ocean.core.handlers.port_app_config.models import ResourceConfig
 from port_ocean.core.ocean_types import (
@@ -51,7 +50,6 @@ class BaseEntityProcessor(BaseHandler):
         with logger.contextualize(kind=mapping.kind):
             if not raw_data:
                 return CalculationResult(EntitySelectorDiff([], []), [])
-
             return await self._parse_items(
                 mapping, raw_data, parse_all, send_raw_data_examples_amount
             )

port_ocean/core/handlers/port_app_config/models.py

@@ -22,7 +22,7 @@ class EntityMapping(BaseModel):
     identifier: str | IngestSearchQuery
     title: str | None
     blueprint: str
-    team: str | None
+    team: str | IngestSearchQuery | None
     properties: dict[str, str] = Field(default_factory=dict)
     relations: dict[str, str | IngestSearchQuery] = Field(default_factory=dict)
 

port_ocean/core/handlers/resync_state_updater/updater.py

@@ -3,6 +3,8 @@ from typing import Any, Literal
 from port_ocean.clients.port.client import PortClient
 from port_ocean.utils.misc import IntegrationStateStatus
 from port_ocean.utils.time import get_next_occurrence
+from port_ocean.context.ocean import ocean
+from port_ocean.helpers.metric.metric import MetricType, MetricPhase
 
 
 class ResyncStateUpdater:
@@ -82,3 +84,10 @@ class ResyncStateUpdater:
             self.last_integration_state_updated_at = integration["resyncState"][
                 "updatedAt"
             ]
+
+        ocean.metrics.set_metric(
+            name=MetricType.SUCCESS_NAME,
+            labels=[ocean.metrics.current_resource_kind(), MetricPhase.RESYNC],
+            value=int(status == IntegrationStateStatus.Completed),
+        )
+        await ocean.metrics.flush(kind=ocean.metrics.current_resource_kind())

port_ocean/core/integrations/mixins/sync_raw.py

@@ -11,6 +11,7 @@ from port_ocean.clients.port.types import UserAgentType
 from port_ocean.context.event import TriggerType, event_context, EventType, event
 from port_ocean.context.ocean import ocean
 from port_ocean.context.resource import resource_context
+from port_ocean.context import resource
 from port_ocean.core.handlers.port_app_config.models import ResourceConfig
 from port_ocean.core.integrations.mixins import HandlerMixin, EventsMixin
 from port_ocean.core.integrations.mixins.utils import (
@@ -30,6 +31,8 @@ from port_ocean.core.ocean_types import (
 )
 from port_ocean.core.utils.utils import resolve_entities_diff, zip_and_sum, gather_and_split_errors_from_results
 from port_ocean.exceptions.core import OceanAbortException
+from port_ocean.helpers.metric.metric import MetricType, MetricPhase
+from port_ocean.helpers.metric.utils import TimeMetric
 
 SEND_RAW_DATA_EXAMPLES_AMOUNT = 5
 
@@ -190,6 +193,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             return resolve_entities_diff(entities, entities_at_port_with_properties)
         return entities
 
+
     async def _fetch_entities_batch_from_port(
         self,
         entities_batch: list[Entity],
@@ -252,7 +256,8 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
 
 
         return CalculationResult(
-            objects_diff[0].entity_selector_diff._replace(passed=modified_objects),
+            number_of_transformed_entities=len(objects_diff[0].entity_selector_diff.passed),
+            entity_selector_diff=objects_diff[0].entity_selector_diff._replace(passed=modified_objects),
             errors=objects_diff[0].errors,
             misonfigured_entity_keys=objects_diff[0].misonfigured_entity_keys
         )
@@ -270,7 +275,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             return [], []
 
         objects_diff = await self._calculate_raw([(resource, results)])
-        entities_selector_diff, errors, _ = objects_diff[0]
+        entities_selector_diff, errors, _, _ = objects_diff[0]
 
         await self.entities_state_applier.delete(
             entities_selector_diff.passed, user_agent_type
@@ -278,6 +283,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         logger.info("Finished unregistering change")
         return entities_selector_diff.passed, errors
 
+    @TimeMetric(MetricPhase.RESYNC)
     async def _register_in_batches(
         self, resource_config: ResourceConfig, user_agent_type: UserAgentType
     ) -> tuple[list[Entity], list[Exception]]:
@@ -304,10 +310,16 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             )
             errors.extend(calculation_result.errors)
             passed_entities = list(calculation_result.entity_selector_diff.passed)
+            logger.info(
+                f"Finished registering change for {len(raw_results)} raw results for kind: {resource_config.kind}. {len(passed_entities)} entities were affected"
+            )
 
+        number_of_raw_results = 0
+        number_of_transformed_entities = 0
         for generator in async_generators:
             try:
                 async for items in generator:
+                    number_of_raw_results += len(items)
                     if send_raw_data_examples_amount > 0:
                         send_raw_data_examples_amount = max(
                             0, send_raw_data_examples_amount - len(passed_entities)
@@ -321,12 +333,32 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                     )
                     errors.extend(calculation_result.errors)
                     passed_entities.extend(calculation_result.entity_selector_diff.passed)
+                    number_of_transformed_entities += calculation_result.number_of_transformed_entities
             except* OceanAbortException as error:
                 errors.append(error)
 
         logger.info(
-            f"Finished registering change for {len(results)} raw results for kind: {resource_config.kind}. {len(passed_entities)} entities were affected"
+            f"Finished registering kind: {resource_config.kind}-{resource.resource.index} ,{len(passed_entities)} entities out of {number_of_raw_results} raw results"
+        )
+
+        ocean.metrics.set_metric(
+            name=MetricType.SUCCESS_NAME,
+            labels=[ocean.metrics.current_resource_kind(), MetricPhase.RESYNC],
+            value=int(not errors)
         )
+
+        ocean.metrics.set_metric(
+            name=MetricType.OBJECT_COUNT_NAME,
+            labels=[ocean.metrics.current_resource_kind(), MetricPhase.EXTRACT],
+            value=number_of_raw_results
+        )
+
+        ocean.metrics.set_metric(
+            name=MetricType.OBJECT_COUNT_NAME,
+            labels=[ocean.metrics.current_resource_kind(), MetricPhase.TRANSFORM],
+            value=number_of_transformed_entities
+        )
+
         return passed_entities, errors
 
     async def register_raw(
@@ -356,7 +388,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         if not resource_mappings:
             return []
 
-        diffs, errors, misconfigured_entity_keys = zip(
+        diffs, errors, _, misconfigured_entity_keys = zip(
             *await asyncio.gather(
                 *(
                     self._register_resource_raw(
@@ -510,6 +542,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 {"before": entities_before_flatten, "after": entities_after_flatten},
                 user_agent_type,
             )
+
     async def sort_and_upsert_failed_entities(self,user_agent_type: UserAgentType)->None:
         try:
             if not event.entity_topological_sorter.should_execute():
@@ -524,13 +557,16 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             if isinstance(ocean_abort.__cause__,CycleError):
                 for entity in event.entity_topological_sorter.get_entities(False):
                     await self.entities_state_applier.context.port_client.upsert_entity(entity,event.port_app_config.get_port_request_options(),user_agent_type,should_raise=False)
+
+
+    @TimeMetric(MetricPhase.RESYNC)
     async def sync_raw_all(
         self,
         _: dict[Any, Any] | None = None,
         trigger_type: TriggerType = "machine",
         user_agent_type: UserAgentType = UserAgentType.exporter,
         silent: bool = True,
-    ) -> None:
+    ) -> bool:
         """Perform a full synchronization of raw entities.
 
         This method performs a full synchronization of raw entities, including registration, unregistration,
@@ -543,6 +579,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             silent (bool): Whether to raise exceptions or handle them silently.
         """
         logger.info("Resync was triggered")
+
         async with event_context(
             EventType.RESYNC,
             trigger_type=trigger_type,
@@ -574,18 +611,29 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
 
 
             try:
-                for resource in app_config.resources:
+                for index,resource in enumerate(app_config.resources):
                     # create resource context per resource kind, so resync method could have access to the resource
                     # config as we might have multiple resources in the same event
-                    async with resource_context(resource):
-                        task = asyncio.get_event_loop().create_task(
+                    async with resource_context(resource,index):
+                        resource_kind_id = f"{resource.kind}-{index}"
+                        task = asyncio.create_task(
                             self._register_in_batches(resource, user_agent_type)
                         )
 
                         event.on_abort(lambda: task.cancel())
-                        creation_results.append(await task)
+                        kind_results: tuple[list[Entity], list[Exception]] = await task
+                        ocean.metrics.set_metric(
+                            name=MetricType.OBJECT_COUNT_NAME,
+                            labels=[ocean.metrics.current_resource_kind(), MetricPhase.LOAD],
+                            value=len(kind_results[0])
+                        )
+
+                        creation_results.append(kind_results)
+
+                        await ocean.metrics.flush(kind=resource_kind_id)
 
                 await self.sort_and_upsert_failed_entities(user_agent_type)
+
             except asyncio.CancelledError as e:
                 logger.warning("Resync aborted successfully, skipping delete phase. This leads to an incomplete state")
                 raise
@@ -604,7 +652,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 ]
 
                 if errors:
-                    message = f"Resync failed with {len(errors)}. Skipping delete phase due to incomplete state"
+                    message = f"Resync failed with {len(errors)} errors, skipping delete phase due to incomplete state"
                     error_group = ExceptionGroup(
                         message,
                         errors,
@@ -613,6 +661,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                         raise error_group
 
                     logger.error(message, exc_info=error_group)
+                    return False
                 else:
                     logger.info(
                         f"Running resync diff calculation, number of entities created during sync: {len(generated_entities)}"
@@ -635,3 +684,5 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                             await resync_complete_fn()
 
                         logger.info("Finished executing resync_complete hooks")
+
+                    return True

port_ocean/core/models.py

@@ -40,7 +40,7 @@ class Entity(BaseModel):
     identifier: Any
     blueprint: Any
     title: Any
-    team: str | None | list[Any] = []
+    team: str | None | list[Any] | dict[str, Any] = []
     properties: dict[str, Any] = {}
     relations: dict[str, Any] = {}
 
@@ -50,7 +50,11 @@ class Entity(BaseModel):
 
     @property
     def is_using_search_relation(self) -> bool:
-        return any(isinstance(relation, dict) for relation in self.relations.values())
+        return any(
+            isinstance(relation, dict) for relation in self.relations.values()
+        ) or (
+            self.team is not None and any(isinstance(team, dict) for team in self.team)
+        )
 
 
 class BlueprintRelation(BaseModel):

port_ocean/core/ocean_types.py

@@ -41,6 +41,7 @@ class EntitySelectorDiff(NamedTuple):
 class CalculationResult(NamedTuple):
     entity_selector_diff: EntitySelectorDiff
     errors: list[Exception]
+    number_of_transformed_entities: int = 0
     misonfigured_entity_keys: dict[str, str] = field(default_factory=dict)
 
 

port_ocean/core/utils/utils.py

@@ -110,7 +110,8 @@ def get_port_diff(before: Iterable[Entity], after: Iterable[Entity]) -> EntityPo
 
 
 def are_teams_different(
-    first_team: str | None | list[Any], second_team: str | None | list[Any]
+    first_team: str | None | list[Any] | dict[str, Any],
+    second_team: str | None | list[Any] | dict[str, Any],
 ) -> bool:
     if isinstance(first_team, list) and isinstance(second_team, list):
         return sorted(first_team) != sorted(second_team)
@@ -122,6 +123,7 @@ def are_entities_fields_equal(
 ) -> bool:
     """
     Compare two entity fields by serializing them to JSON and comparing their SHA-256 hashes.
+    Removes keys with None values before comparison if the corresponding key doesn't exist in the other dict.
 
     Args:
         first_entity_field: First entity field dictionary to compare
@@ -130,7 +132,13 @@ def are_entities_fields_equal(
     Returns:
         bool: True if the entity fields have identical content
     """
-    first_props = json.dumps(first_entity_field, sort_keys=True)
+    first_entity_field_copy = first_entity_field.copy()
+
+    for key in list(first_entity_field.keys()):
+        if first_entity_field[key] is None and key not in second_entity_field:
+            del first_entity_field_copy[key]
+
+    first_props = json.dumps(first_entity_field_copy, sort_keys=True)
     second_props = json.dumps(second_entity_field, sort_keys=True)
     first_hash = hashlib.sha256(first_props.encode()).hexdigest()
     second_hash = hashlib.sha256(second_props.encode()).hexdigest()