port-ocean 0.15.3__py3-none-any.whl → 0.16.1__py3-none-any.whl

port_ocean/clients/port/mixins/entities.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any
+from typing import Any, Literal
 from urllib.parse import quote_plus
 
 import httpx
@@ -11,7 +11,8 @@ from port_ocean.clients.port.utils import (
     handle_status_code,
     PORT_HTTP_MAX_CONNECTIONS_LIMIT,
 )
-from port_ocean.core.models import Entity
+from port_ocean.core.models import Entity, PortAPIErrorMessage
+from starlette import status
 
 
 class EntityClientMixin:
@@ -29,7 +30,27 @@ class EntityClientMixin:
         request_options: RequestOptions,
         user_agent_type: UserAgentType | None = None,
         should_raise: bool = True,
-    ) -> Entity | None:
+    ) -> Entity | None | Literal[False]:
+        """
+        This function upserts an entity into Port.
+
+        Usage:
+        ```python
+            upsertedEntity = await self.context.port_client.upsert_entity(
+                            entity,
+                            event.port_app_config.get_port_request_options(),
+                            user_agent_type,
+                            should_raise=False,
+                        )
+        ```
+        :param entity: An Entity to be upserted
+        :param request_options: A dictionary specifying how to upsert the entity
+        :param user_agent_type: a UserAgentType specifying who is preforming the action
+        :param should_raise: A boolean specifying whether the error should be raised or handled silently
+        :return: [Entity] if the upsert occured successfully
+        :return: [None] will be returned if entity is using search identifier
+        :return: [False] will be returned if upsert failed because of unmet dependency
+        """
         validation_only = request_options["validation_only"]
         async with self.semaphore:
             logger.debug(
@@ -50,13 +71,21 @@ class EntityClientMixin:
                 },
                 extensions={"retryable": True},
             )
-
         if response.is_error:
             logger.error(
                 f"Error {'Validating' if validation_only else 'Upserting'} "
                 f"entity: {entity.identifier} of "
                 f"blueprint: {entity.blueprint}"
             )
+            result = response.json()
+
+            if (
+                response.status_code == status.HTTP_404_NOT_FOUND
+                and not result.get("ok")
+                and result.get("error") == PortAPIErrorMessage.NOT_FOUND.value
+            ):
+                # Return false to differentiate from `result_entity.is_using_search_identifier`
+                return False
         handle_status_code(response, should_raise)
         result = response.json()
 

port_ocean/context/event.py

@@ -14,6 +14,7 @@ from typing import (
 from uuid import uuid4
 
 from loguru import logger
+from port_ocean.core.utils.entity_topological_sorter import EntityTopologicalSorter
 from pydispatch import dispatcher  # type: ignore
 from werkzeug.local import LocalStack, LocalProxy
 
@@ -24,6 +25,7 @@ from port_ocean.exceptions.context import (
 )
 from port_ocean.utils.misc import get_time
 
+
 if TYPE_CHECKING:
     from port_ocean.core.handlers.port_app_config.models import (
         ResourceConfig,
@@ -50,6 +52,9 @@ class EventContext:
     _parent_event: Optional["EventContext"] = None
     _event_id: str = field(default_factory=lambda: str(uuid4()))
     _on_abort_callbacks: list[AbortCallbackFunction] = field(default_factory=list)
+    entity_topological_sorter: EntityTopologicalSorter = field(
+        default_factory=EntityTopologicalSorter
+    )
 
     def on_abort(self, func: AbortCallbackFunction) -> None:
         self._on_abort_callbacks.append(func)
@@ -129,6 +134,11 @@ async def event_context(
 ) -> AsyncIterator[EventContext]:
     parent = parent_override or _event_context_stack.top
     parent_attributes = parent.attributes if parent else {}
+    entity_topological_sorter = (
+        parent.entity_topological_sorter
+        if parent and parent.entity_topological_sorter
+        else EntityTopologicalSorter()
+    )
 
     attributes = {**parent_attributes, **(attributes or {})}
     new_event = EventContext(
@@ -138,6 +148,7 @@ async def event_context(
         _parent_event=parent,
         # inherit port app config from parent event, so it can be used in nested events
         _port_app_config=parent.port_app_config if parent else None,
+        entity_topological_sorter=entity_topological_sorter,
     )
     _event_context_stack.push(new_event)
 

port_ocean/core/defaults/initialize.py

@@ -14,7 +14,7 @@ from port_ocean.core.defaults.common import (
 )
 from port_ocean.core.handlers.port_app_config.models import PortAppConfig
 from port_ocean.core.models import Blueprint
-from port_ocean.core.utils import gather_and_split_errors_from_results
+from port_ocean.core.utils.utils import gather_and_split_errors_from_results
 from port_ocean.exceptions.port_defaults import (
     AbortDefaultCreationError,
 )

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

@@ -8,12 +8,11 @@ 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.core.handlers.entities_state_applier.port.order_by_entities_dependencies import (
-    order_by_entities_dependencies,
-)
+
 from port_ocean.core.models import Entity
 from port_ocean.core.ocean_types import EntityDiff
-from port_ocean.core.utils import is_same_entity, get_port_diff
+from port_ocean.core.utils.entity_topological_sorter import EntityTopologicalSorter
+from port_ocean.core.utils.utils import is_same_entity, get_port_diff
 
 
 class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
@@ -106,19 +105,7 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
                 should_raise=False,
             )
         else:
-            entities_with_search_identifier: list[Entity] = []
-            entities_without_search_identifier: list[Entity] = []
             for entity in entities:
-                if entity.is_using_search_identifier:
-                    entities_with_search_identifier.append(entity)
-                else:
-                    entities_without_search_identifier.append(entity)
-
-            ordered_created_entities = reversed(
-                entities_with_search_identifier
-                + order_by_entities_dependencies(entities_without_search_identifier)
-            )
-            for entity in ordered_created_entities:
                 upsertedEntity = await self.context.port_client.upsert_entity(
                     entity,
                     event.port_app_config.get_port_request_options(),
@@ -127,6 +114,9 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
                 )
                 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)
         return modified_entities
 
     async def delete(
@@ -141,7 +131,9 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
                 should_raise=False,
             )
         else:
-            ordered_deleted_entities = order_by_entities_dependencies(entities)
+            ordered_deleted_entities = (
+                EntityTopologicalSorter.order_by_entities_dependencies(entities)
+            )
 
             for entity in ordered_deleted_entities:
                 await self.context.port_client.delete_entity(

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

@@ -14,7 +14,6 @@ def node(entity: Entity) -> Node:
 def order_by_entities_dependencies(entities: list[Entity]) -> list[Entity]:
     nodes: dict[Node, Set[Node]] = {}
     entities_map = {}
-
     for entity in entities:
         nodes[node(entity)] = set()
         entities_map[node(entity)] = entity
@@ -33,7 +32,11 @@ def order_by_entities_dependencies(entities: list[Entity]) -> list[Entity]:
         ]
 
         for related_entity in related_entities:
-            nodes[node(entity)].add(node(related_entity))
+            if (
+                entity.blueprint is not related_entity.blueprint
+                or entity.identifier is not related_entity.identifier
+            ):
+                nodes[node(entity)].add(node(related_entity))
 
     sort_op = TopologicalSorter(nodes)
     try:

port_ocean/core/handlers/entity_processor/jq_entity_processor.py

@@ -16,7 +16,10 @@ from port_ocean.core.ocean_types import (
     EntitySelectorDiff,
     CalculationResult,
 )
-from port_ocean.core.utils import gather_and_split_errors_from_results, zip_and_sum
+from port_ocean.core.utils.utils import (
+    gather_and_split_errors_from_results,
+    zip_and_sum,
+)
 from port_ocean.exceptions.core import EntityProcessorException
 from port_ocean.utils.queue_utils import process_in_queue
 
@@ -31,6 +34,7 @@ class MappedEntity:
     entity: dict[str, Any] = field(default_factory=dict)
     did_entity_pass_selector: bool = False
     raw_data: Optional[dict[str, Any]] = None
+    misconfigurations: dict[str, str] = field(default_factory=dict)
 
 
 class JQEntityProcessor(BaseEntityProcessor):
@@ -92,21 +96,37 @@ class JQEntityProcessor(BaseEntityProcessor):
         )
 
     async def _search_as_object(
-        self, data: dict[str, Any], obj: dict[str, Any]
+        self,
+        data: dict[str, Any],
+        obj: dict[str, Any],
+        misconfigurations: dict[str, str] | None = None,
     ) -> dict[str, Any | None]:
+        """
+        Identify and extract the relevant value for the chosen key and populate it into the entity
+        :param data: the property itself that holds the key and the value, it is being passed to the task and we get back a task item,
+            if the data is a dict, we will recursively call this function again.
+        :param obj: the key that we want its value to be mapped into our entity.
+        :param misconfigurations: due to the recursive nature of this function,
+            we aim to have a dict that represents all of the misconfigured properties and when used recursively,
+            we pass this reference to misfoncigured object to add the relevant misconfigured keys.
+        :return: Mapped object with found value.
+        """
+
         search_tasks: dict[
             str, Task[dict[str, Any | None]] | list[Task[dict[str, Any | None]]]
         ] = {}
         for key, value in obj.items():
             if isinstance(value, list):
                 search_tasks[key] = [
-                    asyncio.create_task(self._search_as_object(data, obj))
+                    asyncio.create_task(
+                        self._search_as_object(data, obj, misconfigurations)
+                    )
                     for obj in value
                 ]
 
             elif isinstance(value, dict):
                 search_tasks[key] = asyncio.create_task(
-                    self._search_as_object(data, value)
+                    self._search_as_object(data, value, misconfigurations)
                 )
             else:
                 search_tasks[key] = asyncio.create_task(self._search(data, value))
@@ -115,12 +135,20 @@ class JQEntityProcessor(BaseEntityProcessor):
         for key, task in search_tasks.items():
             try:
                 if isinstance(task, list):
-                    result[key] = [await task for task in task]
+                    result_list = []
+                    for task in task:
+                        task_result = await task
+                        if task_result is None and misconfigurations is not None:
+                            misconfigurations[key] = obj[key]
+                        result_list.append(task_result)
+                    result[key] = result_list
                 else:
-                    result[key] = await task
+                    task_result = await task
+                    if task_result is None and misconfigurations is not None:
+                        misconfigurations[key] = obj[key]
+                    result[key] = task_result
             except Exception:
                 result[key] = None
-
         return result
 
     async def _get_mapped_entity(
@@ -132,11 +160,15 @@ class JQEntityProcessor(BaseEntityProcessor):
     ) -> MappedEntity:
         should_run = await self._search_as_bool(data, selector_query)
         if parse_all or should_run:
-            mapped_entity = await self._search_as_object(data, raw_entity_mappings)
+            misconfigurations: dict[str, str] = {}
+            mapped_entity = await self._search_as_object(
+                data, raw_entity_mappings, misconfigurations
+            )
             return MappedEntity(
                 mapped_entity,
                 did_entity_pass_selector=should_run,
                 raw_data=data if should_run else None,
+                misconfigurations=misconfigurations,
             )
 
         return MappedEntity()
@@ -218,7 +250,11 @@ class JQEntityProcessor(BaseEntityProcessor):
         passed_entities = []
         failed_entities = []
         examples_to_send: list[dict[str, Any]] = []
+        entity_misconfigurations: dict[str, str] = {}
+        missing_required_fields: bool = False
         for result in calculated_entities_results:
+            if len(result.misconfigurations) > 0:
+                entity_misconfigurations |= result.misconfigurations
             if result.entity.get("identifier") and result.entity.get("blueprint"):
                 parsed_entity = Entity.parse_obj(result.entity)
                 if result.did_entity_pass_selector:
@@ -230,6 +266,12 @@ class JQEntityProcessor(BaseEntityProcessor):
                         examples_to_send.append(result.raw_data)
                 else:
                     failed_entities.append(parsed_entity)
+            else:
+                missing_required_fields = True
+        if len(entity_misconfigurations) > 0:
+            logger.info(
+                f"The mapping resulted with invalid values for{" identifier, blueprint," if missing_required_fields else " "} properties. Mapping result: {entity_misconfigurations}"
+            )
         if (
             not calculated_entities_results
             and raw_results
@@ -245,4 +287,5 @@ class JQEntityProcessor(BaseEntityProcessor):
         return CalculationResult(
             EntitySelectorDiff(passed=passed_entities, failed=failed_entities),
             errors,
+            misonfigured_entity_keys=entity_misconfigurations,
         )

port_ocean/core/integrations/mixins/sync_raw.py

@@ -1,4 +1,5 @@
 import asyncio
+from graphlib import CycleError
 import inspect
 import typing
 from typing import Callable, Awaitable, Any
@@ -27,7 +28,7 @@ from port_ocean.core.ocean_types import (
     RAW_ITEM,
     CalculationResult,
 )
-from port_ocean.core.utils import zip_and_sum, gather_and_split_errors_from_results
+from port_ocean.core.utils.utils import zip_and_sum, gather_and_split_errors_from_results
 from port_ocean.exceptions.core import OceanAbortException
 
 SEND_RAW_DATA_EXAMPLES_AMOUNT = 5
@@ -184,7 +185,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         send_raw_data_examples_amount = (
             SEND_RAW_DATA_EXAMPLES_AMOUNT if ocean.config.send_raw_data_examples else 0
         )
-        all_entities, register_errors = await self._register_resource_raw(
+        all_entities, register_errors,_ = await self._register_resource_raw(
             resource_config,
             raw_results,
             user_agent_type,
@@ -201,7 +202,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                             0, send_raw_data_examples_amount - len(passed_entities)
                         )
 
-                    entities, register_errors = await self._register_resource_raw(
+                    entities, register_errors,_ = await self._register_resource_raw(
                         resource_config,
                         items,
                         user_agent_type,
@@ -396,7 +397,20 @@ 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():
+                return None
+            logger.info(f"Executings topological sort of {event.entity_topological_sorter.get_entities_count()} entities failed to upsert.",failed_toupsert_entities_count=event.entity_topological_sorter.get_entities_count())
+
+            for entity in event.entity_topological_sorter.get_entities():
+                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)
+
+        except OceanAbortException as ocean_abort:
+            logger.info(f"Failed topological sort of failed to upsert entites - trying to upsert unordered {event.entity_topological_sorter.get_entities_count()} entities.",failed_topological_sort_entities_count=event.entity_topological_sorter.get_entities_count() )
+            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)
     async def sync_raw_all(
         self,
         _: dict[Any, Any] | None = None,
@@ -426,6 +440,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 use_cache=False
             )
             logger.info(f"Resync will use the following mappings: {app_config.dict()}")
+
             try:
                 did_fetched_current_state = True
                 entities_at_port = await ocean.port_client.search_entities(
@@ -455,6 +470,8 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                         event.on_abort(lambda: task.cancel())
 
                         creation_results.append(await task)
+
+                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

port_ocean/core/integrations/mixins/utils.py

@@ -9,7 +9,7 @@ from port_ocean.core.ocean_types import (
     RESYNC_EVENT_LISTENER,
     RESYNC_RESULT,
 )
-from port_ocean.core.utils import validate_result
+from port_ocean.core.utils.utils import validate_result
 from port_ocean.exceptions.core import (
     RawObjectValidationException,
     OceanAbortException,

port_ocean/core/models.py

@@ -27,6 +27,10 @@ class Runtime(Enum):
         ) or installation_type == self.value
 
 
+class PortAPIErrorMessage(Enum):
+    NOT_FOUND = "not_found"
+
+
 class Entity(BaseModel):
     identifier: Any
     blueprint: Any

port_ocean/core/ocean_types.py

@@ -1,5 +1,13 @@
-from typing import TypedDict, Any, AsyncIterator, Callable, Awaitable, NamedTuple
-
+from typing import (
+    TypedDict,
+    Any,
+    AsyncIterator,
+    Callable,
+    Awaitable,
+    NamedTuple,
+)
+
+from dataclasses import field
 from port_ocean.core.models import Entity
 
 RAW_ITEM = dict[Any, Any]
@@ -30,6 +38,7 @@ class EntitySelectorDiff(NamedTuple):
 class CalculationResult(NamedTuple):
     entity_selector_diff: EntitySelectorDiff
     errors: list[Exception]
+    misonfigured_entity_keys: dict[str, str] = field(default_factory=dict)
 
 
 class IntegrationEventsCallbacks(TypedDict):

port_ocean/core/utils/entity_topological_sorter.py

@@ -0,0 +1,90 @@
+from typing import Any, Generator
+from port_ocean.context import event
+from port_ocean.core.models import Entity
+
+from loguru import logger
+
+from graphlib import TopologicalSorter, CycleError
+from typing import Set
+
+from port_ocean.exceptions.core import OceanAbortException
+
+Node = tuple[str, str]
+
+
+class EntityTopologicalSorter:
+    def __init__(self) -> None:
+        self.entities: list[Entity] = []
+
+    def register_entity(
+        self,
+        entity: Entity,
+    ) -> None:
+        logger.debug(
+            f"Will retry upserting entity - {entity.identifier} at the end of resync"
+        )
+        self.entities.append(entity)
+
+    def should_execute(self) -> int:
+        return not event.event.port_app_config.create_missing_related_entities
+
+    def get_entities_count(self) -> int:
+        return len(self.entities)
+
+    def get_entities(self, sorted: bool = True) -> Generator[Entity, Any, None]:
+        if not sorted:
+            for entity in self.entities:
+                yield entity
+            return
+
+        sorted_and_mapped = EntityTopologicalSorter.order_by_entities_dependencies(
+            self.entities
+        )
+        for entity in sorted_and_mapped:
+            yield entity
+
+    @staticmethod
+    def node(entity: Entity) -> Node:
+        return entity.identifier, entity.blueprint
+
+    @staticmethod
+    def order_by_entities_dependencies(entities: list[Entity]) -> list[Entity]:
+        nodes: dict[Node, Set[Node]] = {}
+        entities_map = {}
+        for entity in entities:
+            nodes[EntityTopologicalSorter.node(entity)] = set()
+            entities_map[EntityTopologicalSorter.node(entity)] = entity
+
+        for entity in entities:
+            relation_target_ids: list[str] = sum(
+                [
+                    identifiers if isinstance(identifiers, list) else [identifiers]
+                    for identifiers in entity.relations.values()
+                    if identifiers is not None
+                ],
+                [],
+            )
+            related_entities = [
+                related
+                for related in entities
+                if related.identifier in relation_target_ids
+            ]
+
+            for related_entity in related_entities:
+                if (
+                    entity.blueprint is not related_entity.blueprint
+                    or entity.identifier is not related_entity.identifier
+                ):
+                    nodes[EntityTopologicalSorter.node(entity)].add(
+                        EntityTopologicalSorter.node(related_entity)
+                    )
+
+        sort_op = TopologicalSorter(nodes)
+        try:
+            return [entities_map[item] for item in sort_op.static_order()]
+        except CycleError as ex:
+            raise OceanAbortException(
+                "Cannot order entities due to cyclic dependencies. \n"
+                "If you do want to have cyclic dependencies, please make sure to set the keys"
+                " 'createMissingRelatedEntities' and 'deleteDependentEntities' in the integration config in Port."
+            ) from ex

port_ocean/run.py

@@ -9,7 +9,7 @@ from port_ocean.bootstrap import create_default_app
 from port_ocean.config.dynamic import default_config_factory
 from port_ocean.config.settings import ApplicationSettings, LogLevelType
 from port_ocean.core.defaults.initialize import initialize_defaults
-from port_ocean.core.utils import validate_integration_runtime
+from port_ocean.core.utils.utils import validate_integration_runtime
 from port_ocean.log.logger_setup import setup_logger
 from port_ocean.ocean import Ocean
 from port_ocean.utils.misc import get_spec_file, load_module

port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py

@@ -269,3 +269,37 @@ class TestJQEntityProcessor:
             assert len(result.entity_selector_diff.passed) == 1
             assert result.entity_selector_diff.passed[0].properties.get("foo") == "bar"
             assert not result.errors
+
+    async def test_parse_items_wrong_mapping(
+        self, mocked_processor: JQEntityProcessor
+    ) -> None:
+        mapping = Mock()
+        mapping.port.entity.mappings.dict.return_value = {
+            "title": ".foo",
+            "identifier": ".ark",
+            "blueprint": ".baz",
+            "properties": {
+                "description": ".bazbar",
+                "url": ".foobar",
+                "defaultBranch": ".bar.baz",
+            },
+        }
+        mapping.port.items_to_parse = None
+        mapping.selector.query = "true"
+        raw_results = [
+            {
+                "foo": "bar",
+                "baz": "bazbar",
+                "bar": {"foobar": "barfoo", "baz": "barbaz"},
+            },
+            {"foo": "bar", "baz": "bazbar", "bar": {"foobar": "foobar"}},
+        ]
+        result = await mocked_processor._parse_items(mapping, raw_results)
+        assert len(result.misonfigured_entity_keys) > 0
+        assert len(result.misonfigured_entity_keys) == 4
+        assert result.misonfigured_entity_keys == {
+            "identifier": ".ark",
+            "description": ".bazbar",
+            "url": ".foobar",
+            "defaultBranch": ".bar.baz",
+        }

port_ocean/tests/core/handlers/mixins/test_sync_raw.py

@@ -0,0 +1,400 @@
+from contextlib import asynccontextmanager
+from graphlib import CycleError
+from typing import Any, AsyncGenerator
+
+from httpx import Response
+from port_ocean.clients.port.client import PortClient
+from port_ocean.core.utils.entity_topological_sorter import EntityTopologicalSorter
+from port_ocean.exceptions.core import OceanAbortException
+import pytest
+from unittest.mock import MagicMock, AsyncMock, patch
+from port_ocean.ocean import Ocean
+from port_ocean.context.ocean import PortOceanContext
+from port_ocean.core.handlers.port_app_config.models import (
+    EntityMapping,
+    MappingsConfig,
+    PortAppConfig,
+    PortResourceConfig,
+    ResourceConfig,
+    Selector,
+)
+from port_ocean.core.integrations.mixins import SyncRawMixin
+from port_ocean.core.handlers.entities_state_applier.port.applier import (
+    HttpEntitiesStateApplier,
+)
+from port_ocean.core.handlers.entity_processor.jq_entity_processor import (
+    JQEntityProcessor,
+)
+from port_ocean.core.models import Entity
+from port_ocean.context.event import EventContext, event_context, EventType
+from port_ocean.clients.port.types import UserAgentType
+from port_ocean.context.ocean import ocean
+
+
+@pytest.fixture
+def mock_port_client(mock_http_client: MagicMock) -> PortClient:
+    mock_port_client = PortClient(
+        MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock()
+    )
+    mock_port_client.auth = AsyncMock()
+    mock_port_client.auth.headers = AsyncMock(
+        return_value={
+            "Authorization": "test",
+            "User-Agent": "test",
+        }
+    )
+
+    mock_port_client.search_entities = AsyncMock(return_value=[])  # type: ignore
+    mock_port_client.client = mock_http_client
+    return mock_port_client
+
+
+@pytest.fixture
+def mock_http_client() -> MagicMock:
+    mock_http_client = MagicMock()
+    mock_upserted_entities = []
+
+    async def post(url: str, *args: Any, **kwargs: Any) -> Response:
+        entity = kwargs.get("json", {})
+        if entity.get("properties", {}).get("mock_is_to_fail", {}):
+            return Response(
+                404, headers=MagicMock(), json={"ok": False, "error": "not_found"}
+            )
+
+        mock_upserted_entities.append(
+            f"{entity.get('identifier')}-{entity.get('blueprint')}"
+        )
+        return Response(
+            200,
+            json={
+                "entity": {
+                    "identifier": entity.get("identifier"),
+                    "blueprint": entity.get("blueprint"),
+                }
+            },
+        )
+
+    mock_http_client.post = AsyncMock(side_effect=post)
+    return mock_http_client
+
+
+@pytest.fixture
+def mock_ocean(mock_port_client: PortClient) -> Ocean:
+    with patch("port_ocean.ocean.Ocean.__init__", return_value=None):
+        ocean_mock = Ocean(
+            MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock()
+        )
+        ocean_mock.config = MagicMock()
+        ocean_mock.config.port = MagicMock()
+        ocean_mock.config.port.port_app_config_cache_ttl = 60
+        ocean_mock.port_client = mock_port_client
+
+        return ocean_mock
+
+
+@pytest.fixture
+def mock_context(mock_ocean: Ocean) -> PortOceanContext:
+    context = PortOceanContext(mock_ocean)
+    ocean._app = context.app
+    return context
+
+
+@pytest.fixture
+def mock_port_app_config() -> PortAppConfig:
+    return PortAppConfig(
+        enable_merge_entity=True,
+        delete_dependent_entities=True,
+        create_missing_related_entities=False,
+        resources=[
+            ResourceConfig(
+                kind="project",
+                selector=Selector(query="true"),
+                port=PortResourceConfig(
+                    entity=MappingsConfig(
+                        mappings=EntityMapping(
+                            identifier=".id | tostring",
+                            title=".name",
+                            blueprint='"service"',
+                            properties={"url": ".web_url"},
+                            relations={},
+                        )
+                    )
+                ),
+            )
+        ],
+    )
+
+
+@pytest.fixture
+def mock_port_app_config_handler(mock_port_app_config: PortAppConfig) -> MagicMock:
+    handler = MagicMock()
+
+    async def get_config(use_cache: bool = True) -> Any:
+        return mock_port_app_config
+
+    handler.get_port_app_config = get_config
+    return handler
+
+
+@pytest.fixture
+def mock_entity_processor(mock_context: PortOceanContext) -> JQEntityProcessor:
+    return JQEntityProcessor(mock_context)
+
+
+@pytest.fixture
+def mock_entities_state_applier(
+    mock_context: PortOceanContext,
+) -> HttpEntitiesStateApplier:
+    return HttpEntitiesStateApplier(mock_context)
+
+
+@pytest.fixture
+def mock_sync_raw_mixin(
+    mock_entity_processor: JQEntityProcessor,
+    mock_entities_state_applier: HttpEntitiesStateApplier,
+    mock_port_app_config_handler: MagicMock,
+) -> SyncRawMixin:
+    sync_raw_mixin = SyncRawMixin()
+    sync_raw_mixin._entity_processor = mock_entity_processor
+    sync_raw_mixin._entities_state_applier = mock_entities_state_applier
+    sync_raw_mixin._port_app_config_handler = mock_port_app_config_handler
+    sync_raw_mixin._get_resource_raw_results = AsyncMock(return_value=([{}], []))  # type: ignore
+    sync_raw_mixin._entity_processor.parse_items = AsyncMock(return_value=MagicMock())  # type: ignore
+
+    return sync_raw_mixin
+
+
+@asynccontextmanager
+async def no_op_event_context(
+    existing_event: EventContext,
+) -> AsyncGenerator[EventContext, None]:
+    yield existing_event
+
+
+def create_entity(
+    id: str, blueprint: str, relation: dict[str, str], is_to_fail: bool
+) -> Entity:
+    entity = Entity(identifier=id, blueprint=blueprint)
+    entity.relations = relation
+    entity.properties = {"mock_is_to_fail": is_to_fail}
+    return entity
+
+
+@pytest.mark.asyncio
+async def test_sync_raw_mixin_self_dependency(
+    mock_sync_raw_mixin: SyncRawMixin,
+) -> None:
+    entities_params = [
+        ("entity_1", "service", {"service": "entity_1"}, True),
+        ("entity_2", "service", {"service": "entity_2"}, False),
+    ]
+    entities = [create_entity(*entity_param) for entity_param in entities_params]
+
+    calc_result_mock = MagicMock()
+    calc_result_mock.entity_selector_diff.passed = entities
+    calc_result_mock.errors = []
+
+    mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
+
+    mock_order_by_entities_dependencies = MagicMock(
+        side_effect=EntityTopologicalSorter.order_by_entities_dependencies
+    )
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        app_config = (
+            await mock_sync_raw_mixin.port_app_config_handler.get_port_app_config(
+                use_cache=False
+            )
+        )
+        event.port_app_config = app_config
+        event.entity_topological_sorter.register_entity = MagicMock(side_effect=event.entity_topological_sorter.register_entity)  # type: ignore
+        event.entity_topological_sorter.get_entities = MagicMock(side_effect=event.entity_topological_sorter.get_entities)  # type: ignore
+
+        with patch(
+            "port_ocean.core.integrations.mixins.sync_raw.event_context",
+            lambda *args, **kwargs: no_op_event_context(event),
+        ):
+            with patch(
+                "port_ocean.core.utils.entity_topological_sorter.EntityTopologicalSorter.order_by_entities_dependencies",
+                mock_order_by_entities_dependencies,
+            ):
+
+                await mock_sync_raw_mixin.sync_raw_all(
+                    trigger_type="machine", user_agent_type=UserAgentType.exporter
+                )
+
+                assert (
+                    len(event.entity_topological_sorter.entities) == 1
+                ), "Expected one failed entity callback due to retry logic"
+                assert event.entity_topological_sorter.register_entity.call_count == 1
+                assert event.entity_topological_sorter.get_entities.call_count == 1
+
+                assert mock_order_by_entities_dependencies.call_count == 1
+                assert [
+                    call[0][0][0]
+                    for call in mock_order_by_entities_dependencies.call_args_list
+                ] == [entity for entity in entities if entity.identifier == "entity_1"]
+
+
+@pytest.mark.asyncio
+async def test_sync_raw_mixin_circular_dependency(
+    mock_sync_raw_mixin: SyncRawMixin, mock_ocean: Ocean
+) -> None:
+    entities_params = [
+        ("entity_1", "service", {"service": "entity_2"}, True),
+        ("entity_2", "service", {"service": "entity_1"}, True),
+    ]
+    entities = [create_entity(*entity_param) for entity_param in entities_params]
+
+    calc_result_mock = MagicMock()
+    calc_result_mock.entity_selector_diff.passed = entities
+    calc_result_mock.errors = []
+
+    mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
+
+    mock_order_by_entities_dependencies = MagicMock(
+        side_effect=EntityTopologicalSorter.order_by_entities_dependencies
+    )
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        app_config = (
+            await mock_sync_raw_mixin.port_app_config_handler.get_port_app_config(
+                use_cache=False
+            )
+        )
+        event.port_app_config = app_config
+        org = event.entity_topological_sorter.register_entity
+
+        def mock_register_entity(*args: Any, **kwargs: Any) -> Any:
+            entity = args[0]
+            entity.properties["mock_is_to_fail"] = False
+            return org(*args, **kwargs)
+
+        event.entity_topological_sorter.register_entity = MagicMock(side_effect=mock_register_entity)  # type: ignore
+        raiesed_error_handle_failed = []
+        org_get_entities = event.entity_topological_sorter.get_entities
+
+        def handle_failed_wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return list(org_get_entities(*args, **kwargs))
+            except Exception as e:
+                raiesed_error_handle_failed.append(e)
+                raise e
+
+        event.entity_topological_sorter.get_entities = MagicMock(side_effect=lambda *args, **kwargs: handle_failed_wrapper(*args, **kwargs))  # type: ignore
+
+        with patch(
+            "port_ocean.core.integrations.mixins.sync_raw.event_context",
+            lambda *args, **kwargs: no_op_event_context(event),
+        ):
+            with patch(
+                "port_ocean.core.utils.entity_topological_sorter.EntityTopologicalSorter.order_by_entities_dependencies",
+                mock_order_by_entities_dependencies,
+            ):
+
+                await mock_sync_raw_mixin.sync_raw_all(
+                    trigger_type="machine", user_agent_type=UserAgentType.exporter
+                )
+
+                assert (
+                    len(event.entity_topological_sorter.entities) == 2
+                ), "Expected one failed entity callback due to retry logic"
+                assert event.entity_topological_sorter.register_entity.call_count == 2
+                assert event.entity_topological_sorter.get_entities.call_count == 2
+                assert [
+                    call[0]
+                    for call in event.entity_topological_sorter.get_entities.call_args_list
+                ] == [(), (False,)]
+                assert len(raiesed_error_handle_failed) == 1
+                assert isinstance(raiesed_error_handle_failed[0], OceanAbortException)
+                assert isinstance(raiesed_error_handle_failed[0].__cause__, CycleError)
+                assert (
+                    len(mock_ocean.port_client.client.post.call_args_list)  # type: ignore
+                    / len(entities)
+                    == 2
+                )
+
+
+@pytest.mark.asyncio
+async def test_sync_raw_mixin_dependency(
+    mock_sync_raw_mixin: SyncRawMixin, mock_ocean: Ocean
+) -> None:
+    entities_params = [
+        ("entity_1", "service", {"service": "entity_3"}, True),
+        ("entity_2", "service", {"service": "entity_4"}, True),
+        ("entity_3", "service", {"service": ""}, True),
+        ("entity_4", "service", {"service": "entity_3"}, True),
+        ("entity_5", "service", {"service": "entity_1"}, True),
+    ]
+    entities = [create_entity(*entity_param) for entity_param in entities_params]
+
+    calc_result_mock = MagicMock()
+    calc_result_mock.entity_selector_diff.passed = entities
+    calc_result_mock.errors = []
+
+    mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
+
+    mock_order_by_entities_dependencies = MagicMock(
+        side_effect=EntityTopologicalSorter.order_by_entities_dependencies
+    )
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        app_config = (
+            await mock_sync_raw_mixin.port_app_config_handler.get_port_app_config(
+                use_cache=False
+            )
+        )
+        event.port_app_config = app_config
+        org = event.entity_topological_sorter.register_entity
+
+        def mock_register_entity(*args: Any, **kwargs: Any) -> None:
+            entity = args[0]
+            entity.properties["mock_is_to_fail"] = False
+            return org(*args, **kwargs)
+
+        event.entity_topological_sorter.register_entity = MagicMock(side_effect=mock_register_entity)  # type: ignore
+        raiesed_error_handle_failed = []
+        org_event_get_entities = event.entity_topological_sorter.get_entities
+
+        def get_entities_wrapper(*args: Any, **kwargs: Any) -> Any:
+            try:
+                return org_event_get_entities(*args, **kwargs)
+            except Exception as e:
+                raiesed_error_handle_failed.append(e)
+                raise e
+
+        event.entity_topological_sorter.get_entities = MagicMock(side_effect=lambda *args, **kwargs: get_entities_wrapper(*args, **kwargs))  # type: ignore
+
+        with patch(
+            "port_ocean.core.integrations.mixins.sync_raw.event_context",
+            lambda *args, **kwargs: no_op_event_context(event),
+        ):
+            with patch(
+                "port_ocean.core.utils.entity_topological_sorter.EntityTopologicalSorter.order_by_entities_dependencies",
+                mock_order_by_entities_dependencies,
+            ):
+
+                await mock_sync_raw_mixin.sync_raw_all(
+                    trigger_type="machine", user_agent_type=UserAgentType.exporter
+                )
+
+                assert event.entity_topological_sorter.register_entity.call_count == 5
+                assert (
+                    len(event.entity_topological_sorter.entities) == 5
+                ), "Expected one failed entity callback due to retry logic"
+                assert event.entity_topological_sorter.get_entities.call_count == 1
+                assert len(raiesed_error_handle_failed) == 0
+                assert mock_ocean.port_client.client.post.call_count == 10  # type: ignore
+                assert mock_order_by_entities_dependencies.call_count == 1
+
+                first = mock_ocean.port_client.client.post.call_args_list[0:5]  # type: ignore
+                second = mock_ocean.port_client.client.post.call_args_list[5:10]  # type: ignore
+
+                assert "-".join(
+                    [call[1].get("json").get("identifier") for call in first]
+                ) == "-".join([entity.identifier for entity in entities])
+                assert "-".join(
+                    [call[1].get("json").get("identifier") for call in second]
+                ) in (
+                    "entity_3-entity_4-entity_1-entity_2-entity_5",
+                    "entity_3-entity_4-entity_1-entity_5-entity_2",
+                    "entity_3-entity_1-entity_4-entity_2-entity_5",
+                    "entity_3-entity_1-entity_4-entity_5-entity_2",
+                )

port_ocean/tests/core/test_utils.py

@@ -2,7 +2,7 @@ from unittest.mock import AsyncMock, patch
 
 import pytest
 
-from port_ocean.core.utils import validate_integration_runtime
+from port_ocean.core.utils.utils import validate_integration_runtime
 from port_ocean.clients.port.client import PortClient
 from port_ocean.core.models import Runtime
 from port_ocean.tests.helpers.port_client import get_port_client_for_integration

port_ocean/tests/core/utils/test_entity_topological_sorter.py

@@ -0,0 +1,99 @@
+from port_ocean.core.models import Entity
+from port_ocean.core.utils.entity_topological_sorter import EntityTopologicalSorter
+from unittest.mock import MagicMock
+from port_ocean.exceptions.core import (
+    OceanAbortException,
+)
+
+
+def create_entity(
+    identifier: str, buleprint: str, dependencies: dict[str, str] = {}
+) -> Entity:
+    entity = MagicMock()
+    entity.identifier = identifier
+    entity.blueprint = buleprint
+    entity.relations = dependencies or {}
+    return entity
+
+
+def test_handle_failed_with_dependencies() -> None:
+    # processed_order:list[str] = []
+    entity_a = create_entity(
+        "entity_a",
+        "buleprint_a",
+    )  # No dependencies
+    entity_b = create_entity(
+        "entity_b", "buleprint_a", {"dep_name_1": "entity_a"}
+    )  # Depends on entity_a
+    entity_c = create_entity(
+        "entity_c", "buleprint_b", {"dep_name_2": "entity_b"}
+    )  # Depends on entity_b
+
+    entity_topological_sort = EntityTopologicalSorter()
+    # Register fails with unsorted order
+    entity_topological_sort.register_entity(entity_c)
+    entity_topological_sort.register_entity(entity_a)
+    entity_topological_sort.register_entity(entity_b)
+
+    processed_order = [
+        f"{entity.identifier}-{entity.blueprint}"
+        for entity in list(entity_topological_sort.get_entities())
+    ]
+    assert processed_order == [
+        "entity_a-buleprint_a",
+        "entity_b-buleprint_a",
+        "entity_c-buleprint_b",
+    ], f"Processed order: {processed_order}"
+
+
+def test_handle_failed_with_self_dependencies() -> None:
+    entity_a = create_entity(
+        "entity_a", "buleprint_a", {"dep_name_1": "entity_a"}
+    )  # Self dependency
+    entity_b = create_entity(
+        "entity_b", "buleprint_a", {"dep_name_1": "entity_a"}
+    )  # Depends on entity_a
+    entity_c = create_entity(
+        "entity_c", "buleprint_b", {"dep_name_2": "entity_b"}
+    )  # Depends on entity_b
+
+    entity_topological_sort = EntityTopologicalSorter()
+
+    # Register fails with unsorted order
+    entity_topological_sort.register_entity(entity_c)
+    entity_topological_sort.register_entity(entity_a)
+    entity_topological_sort.register_entity(entity_b)
+
+    processed_order = [
+        f"{entity.identifier}-{entity.blueprint}"
+        for entity in list(entity_topological_sort.get_entities())
+    ]
+
+    assert processed_order == [
+        "entity_a-buleprint_a",
+        "entity_b-buleprint_a",
+        "entity_c-buleprint_b",
+    ], f"Processed order: {processed_order}"
+
+
+def test_handle_failed_with_circular_dependencies() -> None:
+    # processed_order:list[str] = []
+    entity_a = create_entity(
+        "entity_a", "buleprint_a", {"dep_name_1": "entity_b"}
+    )  # Self dependency
+    entity_b = create_entity(
+        "entity_b", "buleprint_a", {"dep_name_1": "entity_a"}
+    )  # Depends on entity_a
+
+    entity_topological_sort = EntityTopologicalSorter()
+    try:
+        entity_topological_sort.register_entity(entity_a)
+        entity_topological_sort.register_entity(entity_b)
+        entity_topological_sort.get_entities()
+
+    except OceanAbortException as e:
+        assert isinstance(e, OceanAbortException)
+        assert (
+            e.args[0]
+            == "Cannot order entities due to cyclic dependencies. \nIf you do want to have cyclic dependencies, please make sure to set the keys 'createMissingRelatedEntities' and 'deleteDependentEntities' in the integration config in Port."
+        )

{port_ocean-0.15.3.dist-info → port_ocean-0.16.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.15.3
+Version: 0.16.1
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port

{port_ocean-0.15.3.dist-info → port_ocean-0.16.1.dist-info}/RECORD

@@ -49,7 +49,7 @@ port_ocean/clients/port/authentication.py,sha256=6-uDMWsJ0xLe1-9IoYXHWmwtufj8rJR
 port_ocean/clients/port/client.py,sha256=Xd8Jk25Uh4WXY_WW-z1Qbv6F3ZTBFPoOolsxHMfozKw,3366
 port_ocean/clients/port/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/clients/port/mixins/blueprints.py,sha256=POBl4uDocrgJBw4rvCAzwRcD4jk-uBL6pDAuKMTajdg,4633
-port_ocean/clients/port/mixins/entities.py,sha256=CnSU3dw1RTZUWYBTLP3KP7CyMweNcoDi1OlSWBwjXWU,8894
+port_ocean/clients/port/mixins/entities.py,sha256=zVOltaiX3Hx8k_CLjBZ5QFH0r_fQOGMimJ6jAJf9jwI,10327
 port_ocean/clients/port/mixins/integrations.py,sha256=t8OSa7Iopnpp8IOEcp3a7WgwOcJEBdFow9UbGDKWxKI,4858
 port_ocean/clients/port/mixins/migrations.py,sha256=A6896oJF6WbFL2WroyTkMzr12yhVyWqGoq9dtLNSKBY,1457
 port_ocean/clients/port/retry_transport.py,sha256=PtIZOAZ6V-ncpVysRUsPOgt8Sf01QLnTKB5YeKBxkJk,1861
@@ -62,14 +62,14 @@ port_ocean/config/settings.py,sha256=cxGnOTO9cEwwFcTSzOmwMw1yPkQHniVJFyCQCyEZ6yY
 port_ocean/consumers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/consumers/kafka_consumer.py,sha256=N8KocjBi9aR0BOPG8hgKovg-ns_ggpEjrSxqSqF_BSo,4710
 port_ocean/context/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/context/event.py,sha256=WduGbCPgm2J2a63EY4J3XWwFGSt3ja1acBVpyI_ciMo,5430
+port_ocean/context/event.py,sha256=tf254jMqBW1GBmYDhfXMCkOqHA7C_chaYp1OY3Dfnsg,5869
 port_ocean/context/ocean.py,sha256=2EreWOj-N2H7QUjEt5wGiv5KHP4pTZc70tn_wHcpF4w,4657
 port_ocean/context/resource.py,sha256=yDj63URzQelj8zJPh4BAzTtPhpKr9Gw9DRn7I_0mJ1s,1692
 port_ocean/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/defaults/__init__.py,sha256=8qCZg8n06WAdMu9s_FiRtDYLGPGHbOuS60vapeUoAks,142
 port_ocean/core/defaults/clean.py,sha256=TOVe5b5FAjFspAkQuKA70k2BClCEFbrQ3xgiAoKXKYE,2427
 port_ocean/core/defaults/common.py,sha256=zJsj7jvlqIMLGXhdASUlbKS8GIAf-FDKKB0O7jB6nx0,4166
-port_ocean/core/defaults/initialize.py,sha256=M1EXgfbnrvP5e3f9or8Bi0-4zXECznfRfy7sJn2Gc14,8471
+port_ocean/core/defaults/initialize.py,sha256=eX5AMo3fug202lHvnwwGAuYlVbh3yDvUQaimTzre1do,8477
 port_ocean/core/event_listener/__init__.py,sha256=mzJ33wRq0kh60fpVdOHVmvMTUQIvz3vxmifyBgwDn0E,889
 port_ocean/core/event_listener/base.py,sha256=1Nmpg00OfT2AD2L8eFm4VQEcdG2TClpSWJMhWhAjkEE,2356
 port_ocean/core/event_listener/factory.py,sha256=AYYfSHPAF7P5H-uQECXT0JVJjKDHrYkWJJBSL4mGkg8,3697
@@ -82,12 +82,12 @@ port_ocean/core/handlers/base.py,sha256=cTarblazu8yh8xz2FpB-dzDKuXxtoi143XJgPbV_
 port_ocean/core/handlers/entities_state_applier/__init__.py,sha256=kgLZDCeCEzi4r-0nzW9k78haOZNf6PX7mJOUr34A4c8,173
 port_ocean/core/handlers/entities_state_applier/base.py,sha256=5wHL0icfFAYRPqk8iV_wN49GdJ3aRUtO8tumSxBi4Wo,2268
 port_ocean/core/handlers/entities_state_applier/port/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/core/handlers/entities_state_applier/port/applier.py,sha256=EirgWhT_TNeEwfdCElEDGkJ2tSOz9HsaUJ1i2uD7z28,5922
+port_ocean/core/handlers/entities_state_applier/port/applier.py,sha256=FSJ77o-lilv5tF5WgpPNjA5lAw13CseFilL-kMHIF3A,5564
 port_ocean/core/handlers/entities_state_applier/port/get_related_entities.py,sha256=1zncwCbE-Gej0xaWKlzZgoXxOBe9bgs_YxlZ8QW3NdI,1751
-port_ocean/core/handlers/entities_state_applier/port/order_by_entities_dependencies.py,sha256=82BvU8t5w9uhsxX8hbnwuRPuWhW3cMeuT_5sVIkip1I,1550
+port_ocean/core/handlers/entities_state_applier/port/order_by_entities_dependencies.py,sha256=lyv6xKzhYfd6TioUgR3AVRSJqj7JpAaj1LxxU2xAqeo,1720
 port_ocean/core/handlers/entity_processor/__init__.py,sha256=FvFCunFg44wNQoqlybem9MthOs7p1Wawac87uSXz9U8,156
 port_ocean/core/handlers/entity_processor/base.py,sha256=udR0w5TstTOS5xOfTjAZIEdldn4xr6Oyb3DylatYX3Q,1869
-port_ocean/core/handlers/entity_processor/jq_entity_processor.py,sha256=EHxU5PxvGxKJn5gKRO01bMR9PmXM6NC_NZ1L2xqlQsI,8868
+port_ocean/core/handlers/entity_processor/jq_entity_processor.py,sha256=X-up0HVdE8pkITxzvB1BC7W8Oq0C14WbT3WqV7p-wJc,11129
 port_ocean/core/handlers/port_app_config/__init__.py,sha256=8AAT5OthiVM7KCcM34iEgEeXtn2pRMrT4Dze5r1Ixbk,134
 port_ocean/core/handlers/port_app_config/api.py,sha256=6VbKPwFzsWG0IYsVD81hxSmfqtHUFqrfUuj1DBX5g4w,853
 port_ocean/core/handlers/port_app_config/base.py,sha256=4Nxt2g8voEIHJ4Y1Km5NJcaG2iSbCklw5P8-Kus7Y9k,3007
@@ -100,11 +100,12 @@ port_ocean/core/integrations/mixins/__init__.py,sha256=FA1FEKMM6P-L2_m7Q4L20mFa4
 port_ocean/core/integrations/mixins/events.py,sha256=Ddfx2L4FpghV38waF8OfVeOV0bHBxNIgjU-q5ffillI,2341
 port_ocean/core/integrations/mixins/handler.py,sha256=mZ7-0UlG3LcrwJttFbMe-R4xcOU2H_g33tZar7PwTv8,3771
 port_ocean/core/integrations/mixins/sync.py,sha256=B9fEs8faaYLLikH9GBjE_E61vo0bQDjIGQsQ1SRXOlA,3931
-port_ocean/core/integrations/mixins/sync_raw.py,sha256=BGS5EnZ2N3ifcAi94Wo-ZassSJ-_Se9eFJMpBDT7pNY,18841
-port_ocean/core/integrations/mixins/utils.py,sha256=7y1rGETZIjOQadyIjFJXIHKkQFKx_SwiP-TrAIsyyLY,2303
-port_ocean/core/models.py,sha256=71QIFHl-p401h2HnSDQ-aaLXhu6z3iHTwCBI0TewJos,1902
-port_ocean/core/ocean_types.py,sha256=3_d8-n626f1kWLQ_Jxw194LEyrOVupz05qs_Y1pvB-A,990
-port_ocean/core/utils.py,sha256=QSRuF9wlhbOw6cELlDlek_UIX6ciIuKWml8QhBmHU_k,3703
+port_ocean/core/integrations/mixins/sync_raw.py,sha256=Wir4aTSCkIvG6Ny9Eo0Xf55OkSbh_6wHfNSaCffAKJQ,20279
+port_ocean/core/integrations/mixins/utils.py,sha256=oN4Okz6xlaefpid1_Pud8HPSw9BwwjRohyNsknq-Myg,2309
+port_ocean/core/models.py,sha256=O8nOKc4ORZz9tS5s6y5YgGLEBroXpvSPDqKuz48uKvs,1965
+port_ocean/core/ocean_types.py,sha256=j_-or1VxDy22whLLxwxgzIsE4wAhFLH19Xff9l4oJA8,1124
+port_ocean/core/utils/entity_topological_sorter.py,sha256=MDUjM6OuDy4Xj68o-7InNN0w1jqjxeDfeY8U02vySNI,3081
+port_ocean/core/utils/utils.py,sha256=QSRuF9wlhbOw6cELlDlek_UIX6ciIuKWml8QhBmHU_k,3703
 port_ocean/debug_cli.py,sha256=gHrv-Ey3cImKOcGZpjoHlo4pa_zfmyOl6TUM4o9VtcA,96
 port_ocean/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/exceptions/api.py,sha256=TLmTMqn4uHGaHgZK8PMIJ0TVJlPB4iP7xl9rx7GtCyY,426
@@ -124,14 +125,16 @@ port_ocean/log/sensetive.py,sha256=lVKiZH6b7TkrZAMmhEJRhcl67HNM94e56x12DwFgCQk,2
 port_ocean/middlewares.py,sha256=9wYCdyzRZGK1vjEJ28FY_DkfwDNENmXp504UKPf5NaQ,2727
 port_ocean/ocean.py,sha256=XxO-aRExs1hcy6aJY_nceu-QXRWB2ZLpkIPPuBkp-bQ,5247
 port_ocean/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/run.py,sha256=rTxBlrQd4yyrtgErCFJCHCEHs7d1OXrRiJehUYmIbN0,2212
+port_ocean/run.py,sha256=YnqchtVI6diuc6HcyqjcKVqcO0PYnfYjVKVcwKeNO2E,2218
 port_ocean/sonar-project.properties,sha256=X_wLzDOkEVmpGLRMb2fg9Rb0DxWwUFSvESId8qpvrPI,73
 port_ocean/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/tests/clients/port/mixins/test_entities.py,sha256=A9myrnkLhKSQrnOLv1Zz2wiOVSxW65Q9RIUIRbn_V7w,1586
 port_ocean/tests/conftest.py,sha256=JXASSS0IY0nnR6bxBflhzxS25kf4iNaABmThyZ0mZt8,101
 port_ocean/tests/core/defaults/test_common.py,sha256=sR7RqB3ZYV6Xn6NIg-c8k5K6JcGsYZ2SCe_PYX5vLYM,5560
-port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py,sha256=Yv03P-LDcJCKZ21exiTFrcT1eu0zn6Z954dilxrb52Y,10842
-port_ocean/tests/core/test_utils.py,sha256=94940TerN38jy81ebLJ2Fzf5JJUaV9krnce75APCwmM,2641
+port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py,sha256=C2nLgapTdXRrzP5B4xBuHcc14L-NztFpxLIv8Iuv6Gg,12046
+port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=RPrbw4Zs6bmhL9zMQviq7-qMfgP5_4nJDkfZiAukK-g,15782
+port_ocean/tests/core/test_utils.py,sha256=Z3kdhb5V7Svhcyy3EansdTpgHL36TL6erNtU-OPwAcI,2647
+port_ocean/tests/core/utils/test_entity_topological_sorter.py,sha256=zuq5WSPy_88PemG3mOUIHTxWMR_js1R7tOzUYlgBd68,3447
 port_ocean/tests/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/tests/helpers/fake_port_api.py,sha256=9rtjC6iTQMfzWK6WipkDzzG0b1IIaRmvdJLOyV613vE,6479
 port_ocean/tests/helpers/fixtures.py,sha256=IQEplbHhRgjrAsZlnXrgSYA5YQEn25I9HgO3_Fjibxg,1481
@@ -153,8 +156,8 @@ port_ocean/utils/repeat.py,sha256=0EFWM9d8lLXAhZmAyczY20LAnijw6UbIECf5lpGbOas,32
 port_ocean/utils/signal.py,sha256=K-6kKFQTltcmKDhtyZAcn0IMa3sUpOHGOAUdWKgx0_E,1369
 port_ocean/utils/time.py,sha256=pufAOH5ZQI7gXvOvJoQXZXZJV-Dqktoj9Qp9eiRwmJ4,1939
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.15.3.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.15.3.dist-info/METADATA,sha256=97A1rlQ3w2zUQl6-OKN_6n_yJvMquXcJWwsJ3bNJ3hg,6673
-port_ocean-0.15.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.15.3.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.15.3.dist-info/RECORD,,
+port_ocean-0.16.1.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.16.1.dist-info/METADATA,sha256=6Zbwkb10_nBvr-Yan20BoYf42oD77C0je7Ft2UXmZHs,6673
+port_ocean-0.16.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.16.1.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.16.1.dist-info/RECORD,,