port-ocean 0.24.22__py3-none-any.whl → 0.25.2__py3-none-any.whl

integrations/_infra/Dockerfile.Deb

@@ -3,6 +3,7 @@ ARG BASE_RUNNER_PYTHON_IMAGE=ghcr.io/port-labs/port-ocean-base-runner:latest
 
 FROM ${BASE_BUILDER_PYTHON_IMAGE} AS base
 
+ARG OCEAN_USER_ID=999
 ARG BUILD_CONTEXT
 ARG BUILDPLATFORM
 
@@ -19,7 +20,7 @@ RUN poetry install --without dev --no-root --no-interaction --no-ansi --no-cache
 
 FROM ${BASE_RUNNER_PYTHON_IMAGE} AS prod
 
-RUN groupadd -r appgroup && useradd -r -g appgroup -m ocean
+RUN groupadd -r appgroup && useradd -r -g appgroup -m -u ${OCEAN_USER_ID} ocean
 
 RUN mkdir -p /tmp/ocean
 
@@ -38,6 +39,7 @@ RUN apt-get update \
         ca-certificates \
         openssl \
         curl \
+        acl \
     && apt-get clean
 
 LABEL INTEGRATION_VERSION=${INTEGRATION_VERSION}
@@ -64,7 +66,8 @@ RUN chmod a+x /app/.venv/bin/ocean
 
 RUN chmod a+x /app/init.sh
 RUN ln -s /app/.venv/bin/ocean /usr/bin/ocean
-
+# Add ocean user to ssl certs group
+RUN setfacl -m u:ocean:rwX /etc/ssl/certs
 USER ocean
 # Run the application
 CMD ["bash", "/app/init.sh"]

integrations/_infra/Dockerfile.local

@@ -2,9 +2,10 @@ ARG BASE_PYTHON_IMAGE=debian:trixie-slim
 # debian:trixie-slim - Python 3.12
 FROM ${BASE_PYTHON_IMAGE}
 
-RUN groupadd -r appgroup && useradd -r -g appgroup -m ocean
+ARG OCEAN_USER_ID=999
+RUN groupadd -r appgroup && useradd -r -g appgroup -m -u ${OCEAN_USER_ID} ocean
 
-RUN mkdir -p /tmp/ocean && chown -R ocean:appgroup /tmp/ocean && chmod -R 755 /tmp/ocean
+RUN mkdir -p /tmp/ocean
 
 
 RUN apt-get update \
@@ -27,6 +28,7 @@ RUN apt-get update \
         build-essential\
         git \
         python3-venv \
+        acl \
     && apt-get clean
 
 ARG BUILD_CONTEXT
@@ -40,7 +42,6 @@ ENV PROMETHEUS_MULTIPROC_DIR=${PROMETHEUS_MULTIPROC_DIR}
 RUN mkdir -p ${PROMETHEUS_MULTIPROC_DIR}
 
 WORKDIR /app
-USER ocean
 
 COPY . .
 RUN rm -rf .venv-docker ${BUILD_CONTEXT}/.venv-docker
@@ -51,5 +52,11 @@ RUN python3 -m venv ${BUILD_CONTEXT}/.venv-docker
 WORKDIR /app/${BUILD_CONTEXT}
 
 WORKDIR /app
+RUN chown -R ocean:appgroup /app && chmod -R 755 /app
+RUN chown -R ocean:appgroup /app/${BUILD_CONTEXT} && chmod -R 755 /app/${BUILD_CONTEXT}
+RUN chown -R ocean:appgroup /tmp/ocean && chmod -R 755 /tmp/ocean
+# Add ocean user to ssl certs group
+RUN setfacl -m u:ocean:rwX /etc/ssl/certs
+USER ocean
 
 ENTRYPOINT ["./integrations/_infra/entry_local.sh"]

integrations/_infra/README.md

@@ -0,0 +1,30 @@
+# Running the Ocean image locally using vscode / Cursor
+
+In order to run the local image of Ocean you need to follow these steps:
+
+1. Build the image:
+
+    ```bash
+    docker build -f integrations/_infra/Dockerfile.local --build-arg BUILD_CONTEXT=integrations/<integration_type> --platform linux/arm64 -t <my-local-image>:<local> .
+    ```
+
+2. Run the image
+   1. `5678` is the debugpy port mentioned in the `entry_local.sh` file
+   2. `8000` is the port of the Ocean FastAPI server
+   3. the `-v` option mounts your local Ocean directory to the pod, allowing you not to constantly build the image.
+      1. Make sure to run the command from the root directory of the Ocean repository.
+
+    ```bash
+    docker run --rm -it \
+    -v $(pwd):/app \
+    -p 5678:5678 \
+    -p 8000:8000 \
+    -e BUILD_CONTEXT=integrations/<integration_type> \
+    -e OCEAN__PORT__CLIENT_ID=<MY_CLIENT_ID> \
+    -e OCEAN__PORT__CLIENT_SECRET=<MY_CLIENT_SECRET> \
+    -e OCEAN__PORT__MY_OTHER_CONFIGURATION=<MY_OTHER_CONFIGURATION> \
+    <my-local-image>:<local>
+    ```
+
+3. In vscode/Cursor, run the `Attach to docker fake-integration integration` Running configuration from the `launch.json`.
+4. Have fun debugging!

integrations/_infra/entry_local.sh

@@ -22,4 +22,5 @@ fi
 source .venv-docker/bin/activate
 python -m pip install -e ../../
 
-ocean sail
+python -m pip install debugpy
+python -m debugpy --listen 0.0.0.0:5678 --wait-for-client debug.py

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

@@ -2,6 +2,8 @@ import asyncio
 from collections import defaultdict
 from itertools import groupby
 
+from loguru import logger
+
 from port_ocean.clients.port.client import PortClient
 from port_ocean.core.models import Entity
 
@@ -37,6 +39,11 @@ async def get_related_entities(
     blueprints_to_relations = defaultdict(list)
     for entity, blueprint in entity_to_blueprint:
         for relation_name, relation in entity.relations.items():
+            if relation_name not in blueprint.relations:
+                logger.warning(
+                    f"Relation {relation_name} found in entity {entity.identifier} but not in blueprint {blueprint.identifier}"
+                )
+                continue
             relation_blueprint = blueprint.relations[relation_name].target
             blueprints_to_relations[relation_blueprint].extend(
                 relation if isinstance(relation, list) else [relation]

port_ocean/core/handlers/entity_processor/jq_entity_processor.py

@@ -1,6 +1,7 @@
 import asyncio
 from asyncio import Task
 from dataclasses import dataclass, field
+
 from functools import lru_cache
 from typing import Any, Optional
 import jq  # type: ignore
@@ -23,6 +24,49 @@ from port_ocean.exceptions.core import EntityProcessorException
 from port_ocean.utils.queue_utils import process_in_queue
 
 
+class ExampleStates:
+    __succeed: list[dict[str, Any]]
+    __errors: list[dict[str, Any]]
+    __max_size: int
+
+    def __init__(self, max_size: int = 0) -> None:
+        """
+        Store two sequences:
+          - succeed: items that succeeded
+          - errors:  items that failed
+        """
+        self.__succeed = []
+        self.__errors = []
+        self.__max_size = max_size
+
+    def add_example(self, succeed: bool, item: dict[str, Any]) -> None:
+        if succeed:
+            self.__succeed.append(item)
+        else:
+            self.__errors.append(item)
+
+    def __len__(self) -> int:
+        """
+        Total number of items (successes + errors).
+        """
+        return len(self.__succeed) + len(self.__errors)
+
+    def get_examples(self, number: int = 0) -> list[dict[str, Any]]:
+        """
+        Return a list of up to number items, taking successes first,
+        """
+        if number <= 0:
+            number = self.__max_size
+        # how many from succeed?
+        s_count = min(number, len(self.__succeed))
+        result = list(self.__succeed[:s_count])
+        # how many more from errors?
+        e_count = number - s_count
+        if e_count > 0:
+            result.extend(self.__errors[:e_count])
+        return result
+
+
 @dataclass
 class MappedEntity:
     """Represents the entity after applying the mapping
@@ -182,11 +226,16 @@ class JQEntityProcessor(BaseEntityProcessor):
             return MappedEntity(
                 mapped_entity,
                 did_entity_pass_selector=should_run,
-                raw_data=data if should_run else None,
+                raw_data=data,
                 misconfigurations=misconfigurations,
             )
 
-        return MappedEntity()
+        return MappedEntity(
+            {},
+            did_entity_pass_selector=False,
+            raw_data=data,
+            misconfigurations={},
+        )
 
     async def _calculate_entity(
         self,
@@ -264,24 +313,26 @@ class JQEntityProcessor(BaseEntityProcessor):
 
         passed_entities = []
         failed_entities = []
-        examples_to_send: list[dict[str, Any]] = []
+        examples_to_send = ExampleStates(send_raw_data_examples_amount)
         entity_misconfigurations: dict[str, str] = {}
         missing_required_fields: bool = False
         entity_mapping_fault_counter: int = 0
-
         for result in calculated_entities_results:
             if len(result.misconfigurations) > 0:
                 entity_misconfigurations |= result.misconfigurations
 
+            if (
+                len(examples_to_send) < send_raw_data_examples_amount
+                and result.raw_data is not None
+            ):
+                examples_to_send.add_example(
+                    result.did_entity_pass_selector, result.raw_data
+                )
+
             if result.entity.get("identifier") and result.entity.get("blueprint"):
                 parsed_entity = Entity.parse_obj(result.entity)
                 if result.did_entity_pass_selector:
                     passed_entities.append(parsed_entity)
-                    if (
-                        len(examples_to_send) < send_raw_data_examples_amount
-                        and result.raw_data is not None
-                    ):
-                        examples_to_send.append(result.raw_data)
                 else:
                     failed_entities.append(parsed_entity)
             else:
@@ -294,20 +345,10 @@ class JQEntityProcessor(BaseEntityProcessor):
             entity_mapping_fault_counter,
         )
 
-        if (
-            not calculated_entities_results
-            and raw_results
-            and send_raw_data_examples_amount > 0
-        ):
-            logger.warning(
-                f"No entities were parsed from {len(raw_results)} raw results, sending raw data examples"
-            )
-            examples_to_send = raw_results[:send_raw_data_examples_amount]
-
-        await self._send_examples(examples_to_send, mapping.kind)
+        await self._send_examples(examples_to_send.get_examples(), mapping.kind)
 
         return CalculationResult(
             EntitySelectorDiff(passed=passed_entities, failed=failed_entities),
             errors,
-            misonfigured_entity_keys=entity_misconfigurations,
+            misconfigured_entity_keys=entity_misconfigurations,
         )

port_ocean/core/integrations/mixins/sync_raw.py

@@ -32,9 +32,21 @@ from port_ocean.core.ocean_types import (
     RAW_ITEM,
     CalculationResult,
 )
-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 IntegrationSubProcessFailedException, OceanAbortException
-from port_ocean.helpers.metric.metric import MetricResourceKind, SyncState, MetricType, MetricPhase
+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 (
+    IntegrationSubProcessFailedException,
+    OceanAbortException,
+)
+from port_ocean.helpers.metric.metric import (
+    MetricResourceKind,
+    SyncState,
+    MetricType,
+    MetricPhase,
+)
 from port_ocean.helpers.metric.utils import TimeMetric, TimeMetricWithResourceKind
 from port_ocean.utils.ipc import FileIPC
 
@@ -101,10 +113,14 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         results = []
         for task in fns:
             if inspect.isasyncgenfunction(task):
-                logger.info(f"Found async generator function for {resource_config.kind} name: {task.__qualname__}")
+                logger.info(
+                    f"Found async generator function for {resource_config.kind} name: {task.__qualname__}"
+                )
                 results.append(resync_generator_wrapper(task, resource_config.kind))
             else:
-                logger.info(f"Found sync function for {resource_config.kind} name: {task.__qualname__}")
+                logger.info(
+                    f"Found sync function for {resource_config.kind} name: {task.__qualname__}"
+                )
                 task = typing.cast(Callable[[str], Awaitable[RAW_RESULT]], task)
                 tasks.append(resync_function_wrapper(task, resource_config.kind))
 
@@ -155,14 +171,14 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 {
                     "property": "$identifier",
                     "operator": "in",
-                    "value": [entity.identifier for entity in entities]
+                    "value": [entity.identifier for entity in entities],
                 },
                 {
                     "property": "$blueprint",
                     "operator": "=",
-                    "value": entities[0].blueprint
-                }
-            ]
+                    "value": entities[0].blueprint,
+                },
+            ],
         }
 
     async def _map_entities_compared_with_port(
@@ -174,7 +190,10 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         if not entities:
             return []
 
-        if entities[0].is_using_search_identifier or entities[0].is_using_search_relation:
+        if (
+            entities[0].is_using_search_identifier
+            or entities[0].is_using_search_relation
+        ):
             return entities
 
         MIN_ENTITIES_TO_MAP = 10
@@ -186,21 +205,21 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
 
         # Process entities in batches
         for start_index in range(0, len(entities), BATCH_SIZE):
-            entities_batch = entities[start_index:start_index + BATCH_SIZE]
+            entities_batch = entities[start_index : start_index + BATCH_SIZE]
             batch_results = await self._fetch_entities_batch_from_port(
-                entities_batch,
-                resource,
-                user_agent_type
+                entities_batch, resource, user_agent_type
             )
             entities_at_port_with_properties.extend(batch_results)
 
-        logger.info("Got entities from port with properties and relations", port_entities=len(entities_at_port_with_properties))
+        logger.info(
+            "Got entities from port with properties and relations",
+            port_entities=len(entities_at_port_with_properties),
+        )
 
         if len(entities_at_port_with_properties) > 0:
             return resolve_entities_diff(entities, entities_at_port_with_properties)
         return entities
 
-
     async def _fetch_entities_batch_from_port(
         self,
         entities_batch: list[Entity],
@@ -210,16 +229,18 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         query = self._construct_search_query_for_entities(entities_batch)
         return await ocean.port_client.search_entities(
             user_agent_type,
-            parameters_to_include=["blueprint", "identifier"] + (
-                ["title"] if resource.port.entity.mappings.title != None else []
-            ) + (
-                ["team"] if resource.port.entity.mappings.team != None else []
-            ) + [
-                f"properties.{prop}" for prop in resource.port.entity.mappings.properties
-            ] + [
-                f"relations.{relation}" for relation in resource.port.entity.mappings.relations
+            parameters_to_include=["blueprint", "identifier"]
+            + (["title"] if resource.port.entity.mappings.title != None else [])
+            + (["team"] if resource.port.entity.mappings.team != None else [])
+            + [
+                f"properties.{prop}"
+                for prop in resource.port.entity.mappings.properties
+            ]
+            + [
+                f"relations.{relation}"
+                for relation in resource.port.entity.mappings.relations
             ],
-            query=query
+            query=query,
         )
 
     async def _register_resource_raw(
@@ -228,7 +249,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         results: list[dict[Any, Any]],
         user_agent_type: UserAgentType,
         parse_all: bool = False,
-        send_raw_data_examples_amount: int = 0
+        send_raw_data_examples_amount: int = 0,
     ) -> CalculationResult:
         objects_diff = await self._calculate_raw(
             [(resource, results)], parse_all, send_raw_data_examples_amount
@@ -236,8 +257,12 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
 
         ocean.metrics.inc_metric(
             name=MetricType.OBJECT_COUNT_NAME,
-            labels=[ocean.metrics.current_resource_kind(), MetricPhase.TRANSFORM, MetricPhase.TransformResult.FAILED],
-            value=len(objects_diff[0].entity_selector_diff.failed)
+            labels=[
+                ocean.metrics.current_resource_kind(),
+                MetricPhase.TRANSFORM,
+                MetricPhase.TransformResult.FAILED,
+            ],
+            value=len(objects_diff[0].entity_selector_diff.failed),
         )
 
         modified_objects = []
@@ -247,43 +272,67 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 changed_entities = await self._map_entities_compared_with_port(
                     objects_diff[0].entity_selector_diff.passed,
                     resource,
-                    user_agent_type
+                    user_agent_type,
                 )
                 if changed_entities:
-                    logger.info("Upserting changed entities", changed_entities=len(changed_entities),
-                        total_entities=len(objects_diff[0].entity_selector_diff.passed))
+                    logger.info(
+                        "Upserting changed entities",
+                        changed_entities=len(changed_entities),
+                        total_entities=len(objects_diff[0].entity_selector_diff.passed),
+                    )
                     ocean.metrics.inc_metric(
-                            name=MetricType.OBJECT_COUNT_NAME,
-                            labels=[ocean.metrics.current_resource_kind(), MetricPhase.LOAD, MetricPhase.LoadResult.SKIPPED],
-                            value=len(objects_diff[0].entity_selector_diff.passed) - len(changed_entities)
-                        )
+                        name=MetricType.OBJECT_COUNT_NAME,
+                        labels=[
+                            ocean.metrics.current_resource_kind(),
+                            MetricPhase.LOAD,
+                            MetricPhase.LoadResult.SKIPPED,
+                        ],
+                        value=len(objects_diff[0].entity_selector_diff.passed)
+                        - len(changed_entities),
+                    )
                     await self.entities_state_applier.upsert(
                         changed_entities, user_agent_type
                     )
 
                 else:
-                    logger.info("Entities in batch didn't changed since last sync, skipping", total_entities=len(objects_diff[0].entity_selector_diff.passed))
+                    logger.info(
+                        "Entities in batch didn't changed since last sync, skipping",
+                        total_entities=len(objects_diff[0].entity_selector_diff.passed),
+                    )
                     ocean.metrics.inc_metric(
-                            name=MetricType.OBJECT_COUNT_NAME,
-                            labels=[ocean.metrics.current_resource_kind(), MetricPhase.LOAD, MetricPhase.LoadResult.SKIPPED],
-                            value=len(objects_diff[0].entity_selector_diff.passed)
-                        )
-                modified_objects = [ocean.port_client._reduce_entity(entity) for entity in objects_diff[0].entity_selector_diff.passed]
+                        name=MetricType.OBJECT_COUNT_NAME,
+                        labels=[
+                            ocean.metrics.current_resource_kind(),
+                            MetricPhase.LOAD,
+                            MetricPhase.LoadResult.SKIPPED,
+                        ],
+                        value=len(objects_diff[0].entity_selector_diff.passed),
+                    )
+                modified_objects = [
+                    ocean.port_client._reduce_entity(entity)
+                    for entity in objects_diff[0].entity_selector_diff.passed
+                ]
             except Exception as e:
-                logger.warning(f"Failed to resolve batch entities with Port, falling back to upserting all entities: {str(e)}")
+                logger.warning(
+                    f"Failed to resolve batch entities with Port, falling back to upserting all entities: {str(e)}"
+                )
                 modified_objects = await self.entities_state_applier.upsert(
                     objects_diff[0].entity_selector_diff.passed, user_agent_type
-                    )
+                )
         else:
-           modified_objects = await self.entities_state_applier.upsert(
-                    objects_diff[0].entity_selector_diff.passed, user_agent_type
-                    )
+            modified_objects = await self.entities_state_applier.upsert(
+                objects_diff[0].entity_selector_diff.passed, user_agent_type
+            )
 
         return CalculationResult(
-            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),
+            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
+            misconfigured_entity_keys=objects_diff[0].misconfigured_entity_keys
         )
 
     async def _unregister_resource_raw(
@@ -334,17 +383,17 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 resource_config,
                 raw_results,
                 user_agent_type,
-                send_raw_data_examples_amount=send_raw_data_examples_amount
+                send_raw_data_examples_amount=send_raw_data_examples_amount,
             )
             errors.extend(calculation_result.errors)
             passed_entities = list(calculation_result.entity_selector_diff.passed)
-            number_of_transformed_entities += calculation_result.number_of_transformed_entities
+            number_of_transformed_entities += (
+                calculation_result.number_of_transformed_entities
+            )
             logger.info(
                 f"Finished registering change for {len(raw_results)} raw results for kind: {resource_config.kind}. {len(passed_entities)} entities were affected"
             )
 
-
-
         for generator in async_generators:
             try:
                 async for items in generator:
@@ -358,11 +407,15 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                         resource_config,
                         items,
                         user_agent_type,
-                        send_raw_data_examples_amount=send_raw_data_examples_amount
+                        send_raw_data_examples_amount=send_raw_data_examples_amount,
+                    )
+                    passed_entities.extend(
+                        calculation_result.entity_selector_diff.passed
                     )
-                    passed_entities.extend(calculation_result.entity_selector_diff.passed)
                     errors.extend(calculation_result.errors)
-                    number_of_transformed_entities += calculation_result.number_of_transformed_entities
+                    number_of_transformed_entities += (
+                        calculation_result.number_of_transformed_entities
+                    )
             except* OceanAbortException as error:
                 ocean.metrics.sync_state = SyncState.FAILED
                 errors.append(error)
@@ -371,29 +424,40 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             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)
+            value=int(not errors),
         )
 
         ocean.metrics.inc_metric(
             name=MetricType.OBJECT_COUNT_NAME,
-            labels=[ocean.metrics.current_resource_kind(), MetricPhase.EXTRACT , MetricPhase.ExtractResult.EXTRACTED],
-            value=number_of_raw_results
+            labels=[
+                ocean.metrics.current_resource_kind(),
+                MetricPhase.EXTRACT,
+                MetricPhase.ExtractResult.EXTRACTED,
+            ],
+            value=number_of_raw_results,
         )
 
         ocean.metrics.inc_metric(
             name=MetricType.OBJECT_COUNT_NAME,
-            labels=[ocean.metrics.current_resource_kind(), MetricPhase.TRANSFORM , MetricPhase.TransformResult.TRANSFORMED],
-            value=number_of_transformed_entities
+            labels=[
+                ocean.metrics.current_resource_kind(),
+                MetricPhase.TRANSFORM,
+                MetricPhase.TransformResult.TRANSFORMED,
+            ],
+            value=number_of_transformed_entities,
         )
 
         ocean.metrics.inc_metric(
             name=MetricType.OBJECT_COUNT_NAME,
-            labels=[ocean.metrics.current_resource_kind(), MetricPhase.TRANSFORM , MetricPhase.TransformResult.FILTERED_OUT],
-            value=number_of_raw_results -number_of_transformed_entities
+            labels=[
+                ocean.metrics.current_resource_kind(),
+                MetricPhase.TRANSFORM,
+                MetricPhase.TransformResult.FILTERED_OUT,
+            ],
+            value=number_of_raw_results - number_of_transformed_entities,
         )
 
         return passed_entities, errors
@@ -440,7 +504,6 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         errors = sum(errors, [])
         misconfigured_entity_keys = list(misconfigured_entity_keys)
 
-
         if errors:
             message = f"Failed to register {len(errors)} entities. Skipping delete phase due to incomplete state"
             logger.error(message, exc_info=errors)
@@ -580,34 +643,54 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 user_agent_type,
             )
 
-    async def sort_and_upsert_failed_entities(self,user_agent_type: UserAgentType)->None:
+    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())
+            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)
+                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):
+            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)
+                    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,
+                    )
 
-    def process_resource_in_subprocess(self,
+    def process_resource_in_subprocess(
+        self,
         file_ipc_map: dict[str, FileIPC],
         resource: ResourceConfig,
         index: int,
         user_agent_type: UserAgentType,
     ) -> None:
-        logger.info(f"process started successfully for {resource.kind} with index {index}")
+        logger.info(
+            f"process started successfully for {resource.kind} with index {index}"
+        )
 
         clear_http_client_context()
+
         async def process_resource_task() -> None:
-            result = await self._process_resource(
-                resource, index, user_agent_type
-            )
+            result = await self._process_resource(resource, index, user_agent_type)
             file_ipc_map["process_resource"].save(result)
             file_ipc_map["topological_entities"].save(
                 event.entity_topological_sorter.entities
@@ -616,32 +699,17 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         asyncio.run(process_resource_task())
         logger.info(f"Process finished for {resource.kind} with index {index}")
 
-    async def process_resource(self, resource: ResourceConfig, index: int, user_agent_type: UserAgentType) -> tuple[list[Entity], list[Exception]]:
-            with logger.contextualize(resource_kind=resource.kind, index=index):
-                if ocean.app.process_execution_mode == ProcessExecutionMode.multi_process:
-                    id = uuid.uuid4()
-                    logger.info(f"Starting subprocess with id {id}")
-                    file_ipc_map = {
-                        "process_resource": FileIPC(id, "process_resource",([],[IntegrationSubProcessFailedException(f"Subprocess failed for {resource.kind} with index {index}")])),
-                        "topological_entities": FileIPC(id, "topological_entities",[]),
-                    }
-                    process = ProcessWrapper(target=self.process_resource_in_subprocess, args=(file_ipc_map,resource,index,user_agent_type))
-                    process.start()
-                    await process.join_async()
-
-                    event.entity_topological_sorter.entities.extend(file_ipc_map["topological_entities"].load())
-                    return file_ipc_map["process_resource"].load()
-
-                else:
-                    return await self._process_resource(resource,index,user_agent_type)
-
-    async def _process_resource(self,resource: ResourceConfig, index: int, user_agent_type: UserAgentType)-> tuple[list[Entity], list[Exception]]:
+    async def _process_resource(
+        self, resource: ResourceConfig, index: int, user_agent_type: UserAgentType
+    ) -> tuple[list[Entity], list[Exception]]:
         # 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,index):
+        async with resource_context(resource, index):
             resource_kind_id = f"{resource.kind}-{index}"
             ocean.metrics.sync_state = SyncState.SYNCING
-            await ocean.metrics.report_kind_sync_metrics(kind=resource_kind_id, blueprint=resource.port.entity.mappings.blueprint)
+            await ocean.metrics.report_kind_sync_metrics(
+                kind=resource_kind_id, blueprint=resource.port.entity.mappings.blueprint
+            )
 
             task = asyncio.create_task(
                 self._register_in_batches(resource, user_agent_type)
@@ -652,22 +720,87 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             if ocean.metrics.sync_state != SyncState.FAILED:
                 ocean.metrics.sync_state = SyncState.COMPLETED
 
-            await ocean.metrics.send_metrics_to_webhook(
-                kind=resource_kind_id
+            await ocean.metrics.send_metrics_to_webhook(kind=resource_kind_id)
+            await ocean.metrics.report_kind_sync_metrics(
+                kind=resource_kind_id, blueprint=resource.port.entity.mappings.blueprint
             )
-            await ocean.metrics.report_kind_sync_metrics(kind=resource_kind_id, blueprint=resource.port.entity.mappings.blueprint)
 
             return kind_results
 
-    @TimeMetricWithResourceKind(MetricPhase.RESYNC)
-    async def resync_reconciliation(
+    def resync_reconciliation_in_subprocess(
         self,
+        file_ipc_map: dict[str, FileIPC],
         creation_results: list[tuple[list[Entity], list[Exception]]],
         did_fetched_current_state: bool,
         user_agent_type: UserAgentType,
         app_config: Any,
         silent: bool = True,
     ) -> None:
+        logger.info("Resync reconciliation subprocess started successfully")
+
+        clear_http_client_context()
+
+        async def resync_reconciliation_task() -> None:
+            result = await self._resync_reconciliation(
+                creation_results,
+                did_fetched_current_state,
+                user_agent_type,
+                app_config,
+                silent,
+            )
+            file_ipc_map["resync_reconciliation"].save(result)
+
+        asyncio.run(resync_reconciliation_task())
+        logger.info("Resync reconciliation subprocess finished")
+
+    async def process_resource(
+        self, resource: ResourceConfig, index: int, user_agent_type: UserAgentType
+    ) -> tuple[list[Entity], list[Exception]]:
+        with logger.contextualize(resource_kind=resource.kind, index=index):
+            if ocean.app.process_execution_mode == ProcessExecutionMode.multi_process:
+                id = uuid.uuid4()
+                logger.info(f"Starting subprocess with id {id}")
+                file_ipc_map = {
+                    "process_resource": FileIPC(
+                        str(id),
+                        "process_resource",
+                        (
+                            [],
+                            [
+                                IntegrationSubProcessFailedException(
+                                    f"Subprocess failed for {resource.kind} with index {index}"
+                                )
+                            ],
+                        ),
+                    ),
+                    "topological_entities": FileIPC(
+                        str(id), "topological_entities", []
+                    ),
+                }
+                process = ProcessWrapper(
+                    target=self.process_resource_in_subprocess,
+                    args=(file_ipc_map, resource, index, user_agent_type),
+                )
+                process.start()
+                await process.join_async()
+
+                event.entity_topological_sorter.entities.extend(
+                    file_ipc_map["topological_entities"].load()
+                )
+                return file_ipc_map["process_resource"].load()
+
+            else:
+                return await self._process_resource(resource, index, user_agent_type)
+
+    @TimeMetricWithResourceKind(MetricPhase.RESYNC)
+    async def _resync_reconciliation(
+        self,
+        creation_results: list[tuple[list[Entity], list[Exception]]],
+        did_fetched_current_state: bool,
+        user_agent_type: UserAgentType,
+        app_config: Any,
+        silent: bool = True,
+    ) -> bool:
         """Handle the reconciliation phase of the resync process.
 
         This method handles:
@@ -716,13 +849,12 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         logger.info(
             f"Running resync diff calculation, number of entities created during sync: {len(generated_entities)}"
         )
-        entities_at_port = await ocean.port_client.search_entities(
-            user_agent_type
-        )
+        entities_at_port = await ocean.port_client.search_entities(user_agent_type)
 
         await self.entities_state_applier.delete_diff(
             {"before": entities_at_port, "after": generated_entities},
-            user_agent_type, app_config.get_entity_deletion_threshold()
+            user_agent_type,
+            app_config.get_entity_deletion_threshold(),
         )
 
         logger.info("Resync finished successfully")
@@ -738,6 +870,47 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
 
         return True
 
+    async def resync_reconciliation(
+        self,
+        creation_results: list[tuple[list[Entity], list[Exception]]],
+        did_fetched_current_state: bool,
+        user_agent_type: UserAgentType,
+        app_config: Any,
+        silent: bool = True,
+    ) -> bool:
+        if ocean.app.process_execution_mode == ProcessExecutionMode.multi_process:
+            id = uuid.uuid4()
+            logger.info(f"Starting resync reconciliation in subprocess with id {id}")
+
+            file_ipc_map = {
+                "resync_reconciliation": FileIPC(
+                    str(id), "resync_reconciliation", False
+                ),
+            }
+
+            process = ProcessWrapper(
+                target=self.resync_reconciliation_in_subprocess,
+                args=(
+                    file_ipc_map,
+                    creation_results,
+                    did_fetched_current_state,
+                    user_agent_type,
+                    app_config,
+                    silent,
+                ),
+            )
+            process.start()
+            await process.join_async()
+
+            return file_ipc_map["resync_reconciliation"].load()
+        else:
+            return await self._resync_reconciliation(
+                creation_results,
+                did_fetched_current_state,
+                user_agent_type,
+                app_config,
+                silent,
+            )
 
     @TimeMetric(MetricPhase.RESYNC)
     async def sync_raw_all(
@@ -773,8 +946,14 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             )
             logger.info(f"Resync will use the following mappings: {app_config.dict()}")
 
-            kinds = [f"{resource.kind}-{index}" for index, resource in enumerate(app_config.resources)]
-            blueprints = [resource.port.entity.mappings.blueprint for resource in app_config.resources]
+            kinds = [
+                f"{resource.kind}-{index}"
+                for index, resource in enumerate(app_config.resources)
+            ]
+            blueprints = [
+                resource.port.entity.mappings.blueprint
+                for resource in app_config.resources
+            ]
             ocean.metrics.initialize_metrics(kinds)
             await ocean.metrics.report_sync_metrics(kinds=kinds, blueprints=blueprints)
 
@@ -799,13 +978,19 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
 
             creation_results: list[tuple[list[Entity], list[Exception]]] = []
 
-            multiprocessing.set_start_method('fork', True)
+            multiprocessing.set_start_method("fork", True)
             try:
-                for index,resource in enumerate(app_config.resources):
-                    logger.info(f"Starting processing resource {resource.kind} with index {index}")
-                    creation_results.append(await self.process_resource(resource,index,user_agent_type))
+                for index, resource in enumerate(app_config.resources):
+                    logger.info(
+                        f"Starting processing resource {resource.kind} with index {index}"
+                    )
+                    creation_results.append(
+                        await self.process_resource(resource, index, user_agent_type)
+                    )
             except asyncio.CancelledError as e:
-                logger.warning("Resync aborted successfully, skipping delete phase. This leads to an incomplete state")
+                logger.warning(
+                    "Resync aborted successfully, skipping delete phase. This leads to an incomplete state"
+                )
                 raise
             else:
                 success = await self.resync_reconciliation(
@@ -813,11 +998,16 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                     did_fetched_current_state,
                     user_agent_type,
                     app_config,
-                    silent
+                    silent,
+                )
+                await ocean.metrics.report_sync_metrics(
+                    kinds=[MetricResourceKind.RECONCILIATION]
                 )
-                await ocean.metrics.report_sync_metrics(kinds=[MetricResourceKind.RECONCILIATION])
                 return success
             finally:
                 await ocean.app.cache_provider.clear()
-                if ocean.app.process_execution_mode == ProcessExecutionMode.multi_process:
+                if (
+                    ocean.app.process_execution_mode
+                    == ProcessExecutionMode.multi_process
+                ):
                     ocean.metrics.cleanup_prometheus_metrics()

port_ocean/core/ocean_types.py

@@ -42,7 +42,7 @@ 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)
+    misconfigured_entity_keys: dict[str, str] = field(default_factory=dict)
 
 
 class IntegrationEventsCallbacks(TypedDict):

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

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import cast, Any
 from unittest.mock import AsyncMock, Mock
 from loguru import logger
 import pytest
@@ -10,6 +10,7 @@ from port_ocean.core.handlers.entity_processor.jq_entity_processor import (
 )
 from port_ocean.core.ocean_types import CalculationResult
 from port_ocean.exceptions.core import EntityProcessorException
+from unittest.mock import patch
 
 
 @pytest.mark.asyncio
@@ -296,15 +297,23 @@ class TestJQEntityProcessor:
             },
             {"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",
-        }
+        with patch(
+            "port_ocean.core.handlers.entity_processor.jq_entity_processor.JQEntityProcessor._send_examples"
+        ) as mock_send_examples:
+            result = await mocked_processor._parse_items(
+                mapping, raw_results, send_raw_data_examples_amount=1
+            )
+            assert len(result.misconfigured_entity_keys) > 0
+            assert len(result.misconfigured_entity_keys) == 4
+            assert result.misconfigured_entity_keys == {
+                "identifier": ".ark",
+                "description": ".bazbar",
+                "url": ".foobar",
+                "defaultBranch": ".bar.baz",
+            }
+            assert mock_send_examples.await_args is not None, "mock was not awaited"
+            args, _ = mock_send_examples.await_args
+            assert len(cast(list[Any], args[0])) > 0
 
     async def test_parse_items_empty_required(
         self, mocked_processor: JQEntityProcessor
@@ -324,15 +333,15 @@ class TestJQEntityProcessor:
             {"foo": "identifierMapped", "bar": ""},
         ]
         result = await mocked_processor._parse_items(mapping, raw_results)
-        assert "identifier" not in result.misonfigured_entity_keys
-        assert "blueprint" not in result.misonfigured_entity_keys
+        assert "identifier" not in result.misconfigured_entity_keys
+        assert "blueprint" not in result.misconfigured_entity_keys
 
         raw_results = [
             {"foo": "identifierMapped", "bar": None},
             {"foo": None, "bar": ""},
         ]
         result = await mocked_processor._parse_items(mapping, raw_results)
-        assert result.misonfigured_entity_keys == {
+        assert result.misconfigured_entity_keys == {
             "identifier": ".foo",
             "blueprint": ".bar",
         }

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

@@ -334,7 +334,7 @@ async def test_parse_raw_event_results_to_entities_creation(
     calculation_result = CalculationResult(
         entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]),
         errors=[],
-        misonfigured_entity_keys={},
+        misconfigured_entity_keys={},
     )
     mock_live_events_mixin.entity_processor.parse_items.return_value = (
         calculation_result
@@ -361,7 +361,7 @@ async def test_parse_raw_event_results_to_entities_deletion(
     calculation_result = CalculationResult(
         entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]),
         errors=[],
-        misonfigured_entity_keys={},
+        misconfigured_entity_keys={},
     )
     mock_live_events_mixin.entity_processor.parse_items.return_value = (
         calculation_result

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

@@ -113,7 +113,7 @@ async def test_sync_raw_mixin_self_dependency(
     calc_result_mock.number_of_transformed_entities = len(
         entities
     )  # Add this to match real behavior
-    calc_result_mock.misonfigured_entity_keys = {}  # Add this to match real behavior
+    calc_result_mock.misconfigured_entity_keys = {}  # Add this to match real behavior
 
     mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
 
@@ -234,7 +234,7 @@ async def test_sync_raw_mixin_circular_dependency(
     calc_result_mock.number_of_transformed_entities = len(
         entities
     )  # Add this to match real behavior
-    calc_result_mock.misonfigured_entity_keys = {}  # Add this to match real behavior
+    calc_result_mock.misconfigured_entity_keys = {}  # Add this to match real behavior
 
     mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
 
@@ -378,7 +378,7 @@ async def test_sync_raw_mixin_dependency(
     calc_result_mock.number_of_transformed_entities = len(
         entities
     )  # Add this to match real behavior
-    calc_result_mock.misonfigured_entity_keys = {}  # Add this to match real behavior
+    calc_result_mock.misconfigured_entity_keys = {}  # Add this to match real behavior
 
     # Mock the parse_items method to return our realistic mock
     mock_sync_raw_mixin.entity_processor.parse_items = AsyncMock(return_value=calc_result_mock)  # type: ignore
@@ -773,7 +773,7 @@ class CalculationResult:
     entity_selector_diff: EntitySelectorDiff
     errors: List[Any]
     misconfigurations: List[Any]
-    misonfigured_entity_keys: Optional[List[Any]] = None
+    misconfigured_entity_keys: Optional[List[Any]] = None
 
 
 @pytest.mark.asyncio
@@ -782,7 +782,7 @@ async def test_register_resource_raw_no_changes_upsert_not_called_entitiy_is_ret
     mock_port_app_config: PortAppConfig,
 ) -> None:
     entity = Entity(identifier="1", blueprint="service")
-    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
+    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misconfigured_entity_keys=[])])  # type: ignore
     mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([]))  # type: ignore
     mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock()  # type: ignore
 
@@ -809,7 +809,7 @@ async def test_register_resource_raw_with_changes_upsert_called_and_entities_are
     mock_port_app_config: PortAppConfig,
 ) -> None:
     entity = Entity(identifier="1", blueprint="service")
-    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
+    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misconfigured_entity_keys=[])])  # type: ignore
     mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([entity]))  # type: ignore
     mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock(return_value=[entity])  # type: ignore
 
@@ -836,7 +836,7 @@ async def test_register_resource_raw_with_errors(
 ) -> None:
     failed_entity = Entity(identifier="1", blueprint="service")
     error = Exception("Test error")
-    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[], failed=[failed_entity]), errors=[error], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
+    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[], failed=[failed_entity]), errors=[error], misconfigurations=[], misconfigured_entity_keys=[])])  # type: ignore
     mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([]))  # type: ignore
     mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock()  # type: ignore
 
@@ -873,7 +873,7 @@ async def test_register_resource_raw_skip_event_type_http_request_upsert_called_
         entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]),
         errors=[],
         misconfigurations=[],
-        misonfigured_entity_keys=[],
+        misconfigured_entity_keys=[],
     )
     mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[calculation_result])  # type: ignore
     mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock()  # type: ignore

{port_ocean-0.24.22.dist-info → port_ocean-0.25.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.24.22
+Version: 0.25.2
 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.24.22.dist-info → port_ocean-0.25.2.dist-info}/RECORD

@@ -1,11 +1,12 @@
-integrations/_infra/Dockerfile.Deb,sha256=17iumXYs0jwW8oaLfRFZe35NI9fUKUaUI62zuVzDrHM,1865
+integrations/_infra/Dockerfile.Deb,sha256=YKr_k6A_o7zEd15WYxYMdv9q9vnVZ4Yb2yyj8rb6ihQ,1998
 integrations/_infra/Dockerfile.alpine,sha256=7E4Sb-8supsCcseerHwTkuzjHZoYcaHIyxiBZ-wewo0,3482
 integrations/_infra/Dockerfile.base.builder,sha256=ESe1PKC6itp_AuXawbLI75k1Kruny6NTANaTinxOgVs,743
 integrations/_infra/Dockerfile.base.runner,sha256=uAcs2IsxrAAUHGXt_qULA5INr-HFguf5a5fCKiqEzbY,384
 integrations/_infra/Dockerfile.dockerignore,sha256=CM1Fxt3I2AvSvObuUZRmy5BNLSGC7ylnbpWzFgD4cso,1163
-integrations/_infra/Dockerfile.local,sha256=WmZqwzrxlrQtKrqcGf2vzbVCx3XzISyrwxCuOa4FT28,1250
+integrations/_infra/Dockerfile.local,sha256=v-K0jgDj5vWyF4HCL8-wluUPB04pf9ycEjusRBmIVnc,1527
 integrations/_infra/Makefile,sha256=YgLKvuF_Dw4IA7X98Nus6zIW_3cJ60M1QFGs3imj5c4,2430
-integrations/_infra/entry_local.sh,sha256=GIuAXACcYv4DDxH6ubDidNJboqmAJYW4OanUK_VW4nQ,547
+integrations/_infra/README.md,sha256=ZtJFSMCTU5zTeM8ddRuW1ZL1ga8z7Ic2F3mxmgOSjgo,1195
+integrations/_infra/entry_local.sh,sha256=Sn2TexTEpruH2ixIAGsk-fZV6Y7pT3jd2Pi9TxBeFuw,633
 integrations/_infra/grpcio.sh,sha256=m924poYznoRZ6Tt7Ct8Cs5AV_cmmOx598yIZ3z4DvZE,616
 integrations/_infra/init.sh,sha256=nN8lTrOhB286UfFvD6sJ9YJ-9asT9zVSddQB-RAb7Z4,99
 port_ocean/__init__.py,sha256=uMpjg5d_cXgnyCxA_LmICR8zqBmC6Fe9Ivu9hcvJ7EY,313
@@ -96,11 +97,11 @@ port_ocean/core/handlers/entities_state_applier/__init__.py,sha256=kgLZDCeCEzi4r
 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=NsLW35H1dhP5FFD7kHZxA2ndSBcD_-btan7qNWfvWrs,6683
-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/get_related_entities.py,sha256=XKDIexoDPVWT2-Y1UTKqJJyRUWC3qiHKQD8bozIrni4,2038
 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=PsnpNRqjHth9xwOvDRe7gKu8cjnVV0XGmTIHGvOelX0,1867
-port_ocean/core/handlers/entity_processor/jq_entity_processor.py,sha256=C6zJbS3miKyDeXiEV-0t5vJvkEznOeXRZFFOnwJcNdA,11714
+port_ocean/core/handlers/entity_processor/jq_entity_processor.py,sha256=GxK5BM0yzAoeYTK2-ALKh5qlAe9pebcN7vZfQCZjksM,12787
 port_ocean/core/handlers/port_app_config/__init__.py,sha256=8AAT5OthiVM7KCcM34iEgEeXtn2pRMrT4Dze5r1Ixbk,134
 port_ocean/core/handlers/port_app_config/api.py,sha256=r_Th66NEw38IpRdnXZcRvI8ACfvxW_A6V62WLwjWXlQ,1044
 port_ocean/core/handlers/port_app_config/base.py,sha256=Sup4-X_a7JGa27rMy_OgqGIjFHMlKBpKevicaK3AeHU,2919
@@ -121,10 +122,10 @@ port_ocean/core/integrations/mixins/events.py,sha256=2L7P3Jhp8XBqddh2_o9Cn4N261n
 port_ocean/core/integrations/mixins/handler.py,sha256=mZ7-0UlG3LcrwJttFbMe-R4xcOU2H_g33tZar7PwTv8,3771
 port_ocean/core/integrations/mixins/live_events.py,sha256=zM24dhNc7uHx9XYZ6toVhDADPA90EnpOmZxgDegFZbA,4196
 port_ocean/core/integrations/mixins/sync.py,sha256=Vm_898pLKBwfVewtwouDWsXoxcOLicnAy6pzyqqk6U8,4053
-port_ocean/core/integrations/mixins/sync_raw.py,sha256=mbFRZzG91McaoeLP7rR9TP3Bb1N5zayHwF3t71u-Ncc,34022
+port_ocean/core/integrations/mixins/sync_raw.py,sha256=AzlOARxsKY1YYQ6xhjYiDD-vELkci0Vz7THw8hDVgAU,38522
 port_ocean/core/integrations/mixins/utils.py,sha256=N76dNu1Y6UEg0_pcSdF4RO6dQIZ8EBfX3xMelgWdMxM,3779
 port_ocean/core/models.py,sha256=DNbKpStMINI2lIekKprTqBevqkw_wFuFayN19w1aDfQ,2893
-port_ocean/core/ocean_types.py,sha256=4VipWFOHEh_d9LmWewQccwx1p2dtrRYW0YURVgNsAjo,1398
+port_ocean/core/ocean_types.py,sha256=bkLlTd8XfJK6_JDl0eXUHfE_NygqgiInSMwJ4YJH01Q,1399
 port_ocean/core/utils/entity_topological_sorter.py,sha256=MDUjM6OuDy4Xj68o-7InNN0w1jqjxeDfeY8U02vySNI,3081
 port_ocean/core/utils/utils.py,sha256=XJ6ZZBR5hols19TcX4Bh49ygSNhPt3MLncLR-g41GTA,6858
 port_ocean/debug_cli.py,sha256=gHrv-Ey3cImKOcGZpjoHlo4pa_zfmyOl6TUM4o9VtcA,96
@@ -166,9 +167,9 @@ port_ocean/tests/conftest.py,sha256=JXASSS0IY0nnR6bxBflhzxS25kf4iNaABmThyZ0mZt8,
 port_ocean/tests/core/conftest.py,sha256=7K_M1--wQ08VmiQRB0vo1nst2X00cwsuBS5UfERsnG8,7589
 port_ocean/tests/core/defaults/test_common.py,sha256=sR7RqB3ZYV6Xn6NIg-c8k5K6JcGsYZ2SCe_PYX5vLYM,5560
 port_ocean/tests/core/handlers/entities_state_applier/test_applier.py,sha256=_CZyViY9_gnxjY6ogWcDdmEDuejvpALogf9ESjVAwFY,10675
-port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py,sha256=8WpMn559Mf0TFWmloRpZrVgr6yWwyA0C4n2lVHCtyq4,13596
-port_ocean/tests/core/handlers/mixins/test_live_events.py,sha256=iAwVpr3n3PIkXQLw7hxd-iB_SR_vyfletVXJLOmyz28,12480
-port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=p1AyIc6Rx18miL6Sln9gNvhC39SkXXIqYQstyYDww1c,44420
+port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py,sha256=AyzLclJFKz8YzSi2hiFYVdXRzCFmqQwTxnwNFTo9roU,14091
+port_ocean/tests/core/handlers/mixins/test_live_events.py,sha256=6yUsYooBYchiZP_eYa8PN1IhiztJShBdPguoseyNMzY,12482
+port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=-Jd2rUG63fZM8LuyKtCp1tt4WEqO2m5woESjs1c91sU,44428
 port_ocean/tests/core/handlers/port_app_config/test_api.py,sha256=eJZ6SuFBLz71y4ca3DNqKag6d6HUjNJS0aqQPwiLMTI,1999
 port_ocean/tests/core/handlers/port_app_config/test_base.py,sha256=hSh556bJM9zuELwhwnyKSfd9z06WqWXIfe-6hCl5iKI,9799
 port_ocean/tests/core/handlers/queue/test_local_queue.py,sha256=9Ly0HzZXbs6Rbl_bstsIdInC3h2bgABU3roP9S_PnJM,2582
@@ -202,8 +203,8 @@ port_ocean/utils/repeat.py,sha256=U2OeCkHPWXmRTVoPV-VcJRlQhcYqPWI5NfmPlb1JIbc,32
 port_ocean/utils/signal.py,sha256=mMVq-1Ab5YpNiqN4PkiyTGlV_G0wkUDMMjTZp5z3pb0,1514
 port_ocean/utils/time.py,sha256=pufAOH5ZQI7gXvOvJoQXZXZJV-Dqktoj9Qp9eiRwmJ4,1939
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.24.22.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.24.22.dist-info/METADATA,sha256=50N8hfofvUl4hhRM850KH2qlF6RRBvw-EK_CCOrhFbA,6856
-port_ocean-0.24.22.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.24.22.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.24.22.dist-info/RECORD,,
+port_ocean-0.25.2.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.25.2.dist-info/METADATA,sha256=ruhq57S2upv-BOr7YML2ybb1fCrmXu6PHV_VTLTQnu4,6855
+port_ocean-0.25.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.25.2.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.25.2.dist-info/RECORD,,