port-ocean 0.27.0__py3-none-any.whl → 0.27.10__py3-none-any.whl

integrations/_infra/Dockerfile.Deb

@@ -28,11 +28,14 @@ ARG INTEGRATION_VERSION
 ARG BUILD_CONTEXT
 ARG PROMETHEUS_MULTIPROC_DIR=/tmp/ocean/prometheus/metrics
 ARG OAUTH_CONFIG_DIR=/app/.config
+ARG STREAMING_LOCATION=/tmp/ocean/streaming
 
 ENV LIBRDKAFKA_VERSION=2.8.2 \
-    PROMETHEUS_MULTIPROC_DIR=${PROMETHEUS_MULTIPROC_DIR}
+    PROMETHEUS_MULTIPROC_DIR=${PROMETHEUS_MULTIPROC_DIR} \
+    STREAMING_LOCATION=${STREAMING_LOCATION}
 
 RUN mkdir -p ${PROMETHEUS_MULTIPROC_DIR}
+RUN mkdir -p ${STREAMING_LOCATION}
 RUN chown -R ocean:appgroup /tmp/ocean && chmod -R 755 /tmp/ocean
 
 RUN mkdir -p ${OAUTH_CONFIG_DIR}

integrations/_infra/Dockerfile.local

@@ -33,13 +33,15 @@ RUN apt-get update \
 
 ARG BUILD_CONTEXT
 ARG PROMETHEUS_MULTIPROC_DIR=/tmp/ocean/prometheus/metrics
+ARG STREAMING_LOCATION=/tmp/ocean/streaming
 
 ENV PROMETHEUS_MULTIPROC_DIR=${PROMETHEUS_MULTIPROC_DIR}
-
+ENV STREAMING_LOCATION=${STREAMING_LOCATION}
 # Create /tmp/ocean directory and set permissions
 
 
 RUN mkdir -p ${PROMETHEUS_MULTIPROC_DIR}
+RUN mkdir -p ${STREAMING_LOCATION}
 
 WORKDIR /app
 

port_ocean/clients/port/authentication.py

@@ -35,6 +35,7 @@ class PortAuthentication:
         integration_identifier: str,
         integration_type: str,
         integration_version: str,
+        ingest_url: str,
     ):
         self.client = client
         self.api_url = api_url
@@ -43,6 +44,7 @@ class PortAuthentication:
         self.integration_identifier = integration_identifier
         self.integration_type = integration_type
         self.integration_version = integration_version
+        self.ingest_url = ingest_url
         self.last_token_object: TokenResponse | None = None
 
     async def _get_token(self, client_id: str, client_secret: str) -> TokenResponse:

port_ocean/clients/port/client.py

@@ -1,3 +1,5 @@
+from typing import Any
+
 from loguru import logger
 
 from port_ocean.clients.port.authentication import PortAuthentication
@@ -10,11 +12,10 @@ from port_ocean.clients.port.types import (
     KafkaCreds,
 )
 from port_ocean.clients.port.utils import (
-    handle_port_status_code,
     get_internal_http_client,
+    handle_port_status_code,
 )
 from port_ocean.exceptions.clients import KafkaCredentialsNotFound
-from typing import Any
 
 
 class PortClient(
@@ -32,6 +33,7 @@ class PortClient(
         integration_identifier: str,
         integration_type: str,
         integration_version: str,
+        ingest_url: str,
     ):
         self.api_url = f"{base_url}/v1"
         self.client = get_internal_http_client(self)
@@ -43,6 +45,7 @@ class PortClient(
             integration_identifier,
             integration_type,
             integration_version,
+            ingest_url,
         )
         EntityClientMixin.__init__(self, self.auth, self.client)
         IntegrationClientMixin.__init__(

port_ocean/clients/port/mixins/integrations.py

@@ -296,7 +296,7 @@ class IntegrationClientMixin:
         logger.debug("starting POST raw data request", raw_data=raw_data)
         headers = await self.auth.headers()
         response = await self.client.post(
-            f"{self.auth.api_url}/lakehouse/integration/{self.integration_identifier}/sync/{sync_id}/kind/{kind}/items",
+            f"{self.auth.ingest_url}/lakehouse/integration-type/{self.auth.integration_type}/integration/{self.integration_identifier}/sync/{sync_id}/kind/{kind}/items",
             headers=headers,
             json={
                 "items": raw_data,

port_ocean/config/settings.py

@@ -9,7 +9,6 @@ from pydantic.main import BaseModel
 
 from port_ocean.config.base import BaseOceanModel, BaseOceanSettings
 from port_ocean.core.event_listener import EventListenerSettingsType
-
 from port_ocean.core.models import (
     CachingStorageMode,
     CreatePortResourcesOrigin,
@@ -47,6 +46,7 @@ class PortSettings(BaseOceanModel, extra=Extra.allow):
     client_secret: str = Field(..., sensitive=True)
     base_url: AnyHttpUrl = parse_obj_as(AnyHttpUrl, "https://api.getport.io")
     port_app_config_cache_ttl: int = 60
+    ingest_url: AnyHttpUrl = parse_obj_as(AnyHttpUrl, "https://ingest.getport.io")
 
 
 class IntegrationSettings(BaseOceanModel, extra=Extra.allow):
@@ -73,6 +73,13 @@ class MetricsSettings(BaseOceanModel, extra=Extra.allow):
     webhook_url: str | None = Field(default=None)
 
 
+class StreamingSettings(BaseOceanModel, extra=Extra.allow):
+    enabled: bool = Field(default=False)
+    max_buffer_size_mb: int = Field(default=1024 * 1024 * 20)  # 20 mb
+    chunk_size: int = Field(default=1024 * 64)  # 64 kb
+    location: str = Field(default="/tmp/ocean/streaming")
+
+
 class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     _integration_config_model: BaseModel | None = None
 
@@ -111,6 +118,10 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     upsert_entities_batch_max_length: int = 20
     upsert_entities_batch_max_size_in_bytes: int = 1024 * 1024
     lakehouse_enabled: bool = False
+    yield_items_to_parse: bool = False
+    yield_items_to_parse_batch_size: int = 10
+
+    streaming: StreamingSettings = Field(default_factory=lambda: StreamingSettings())
 
     @validator("process_execution_mode")
     def validate_process_execution_mode(

port_ocean/core/event_listener/kafka.py

@@ -16,6 +16,7 @@ from port_ocean.core.event_listener.base import (
     EventListenerEvents,
     EventListenerSettings,
 )
+from pydantic import validator
 
 
 class KafkaEventListenerSettings(EventListenerSettings):
@@ -46,6 +47,19 @@ class KafkaEventListenerSettings(EventListenerSettings):
     kafka_security_enabled: bool = True
     consumer_poll_timeout: int = 1
 
+    @validator("brokers")
+    @classmethod
+    def parse_brokers(cls, v: str) -> str:
+        # If it's a JSON array string, parse and join
+        if v.strip().startswith("[") and v.strip().endswith("]"):
+            try:
+                parsed = json.loads(v)
+                if isinstance(parsed, list):
+                    return ",".join(parsed)
+            except json.JSONDecodeError:
+                pass
+        return v
+
     def get_changelog_destination_details(self) -> dict[str, Any]:
         """
         Returns the changelog destination configuration for the Kafka event listener.

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

@@ -87,6 +87,15 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
         diff = get_port_diff(entities["before"], entities["after"])
 
         if not diff.deleted:
+            ocean.metrics.inc_metric(
+                name=MetricType.OBJECT_COUNT_NAME,
+                labels=[
+                    ocean.metrics.current_resource_kind(),
+                    MetricPhase.DELETE,
+                    MetricPhase.DeletionResult.DELETED,
+                ],
+                value=0,
+            )
             return
 
         kept_entities = diff.created + diff.modified

port_ocean/core/handlers/entity_processor/jq_entity_processor.py

@@ -242,19 +242,21 @@ class JQEntityProcessor(BaseEntityProcessor):
         data: dict[str, Any],
         raw_entity_mappings: dict[str, Any],
         items_to_parse: str | None,
+        items_to_parse_name: str,
         selector_query: str,
         parse_all: bool = False,
     ) -> tuple[list[MappedEntity], list[Exception]]:
         raw_data = [data.copy()]
-        if items_to_parse:
-            items = await self._search(data, items_to_parse)
-            if not isinstance(items, list):
-                logger.warning(
-                    f"Failed to parse items for JQ expression {items_to_parse}, Expected list but got {type(items)}."
-                    f" Skipping..."
-                )
-                return [], []
-            raw_data = [{"item": item, **data} for item in items]
+        if not ocean.config.yield_items_to_parse:
+            if items_to_parse:
+                items = await self._search(data, items_to_parse)
+                if not isinstance(items, list):
+                    logger.warning(
+                        f"Failed to parse items for JQ expression {items_to_parse}, Expected list but got {type(items)}."
+                        f" Skipping..."
+                    )
+                    return [], []
+                raw_data = [{items_to_parse_name: item, **data} for item in items]
 
         entities, errors = await gather_and_split_errors_from_results(
             [
@@ -303,6 +305,7 @@ class JQEntityProcessor(BaseEntityProcessor):
                 self._calculate_entity,
                 raw_entity_mappings,
                 mapping.port.items_to_parse,
+                mapping.port.items_to_parse_name,
                 mapping.selector.query,
                 parse_all,
             )

port_ocean/core/handlers/port_app_config/models.py

@@ -39,6 +39,7 @@ class MappingsConfig(BaseModel):
 class PortResourceConfig(BaseModel):
     entity: MappingsConfig
     items_to_parse: str | None = Field(alias="itemsToParse")
+    items_to_parse_name: str | None = Field(alias="itemsToParseName", default="item")
 
 
 class Selector(BaseModel):

port_ocean/core/handlers/resync_state_updater/updater.py

@@ -91,6 +91,8 @@ class ResyncStateUpdater:
             value=int(status == IntegrationStateStatus.Completed),
         )
 
+        ocean.metrics.sync_state = status.value
+
         await ocean.metrics.send_metrics_to_webhook(
             kind=ocean.metrics.current_resource_kind()
         )

port_ocean/core/integrations/mixins/sync_raw.py

@@ -116,7 +116,7 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 logger.info(
                     f"Found async generator function for {resource_config.kind} name: {task.__qualname__}"
                 )
-                results.append(resync_generator_wrapper(task, resource_config.kind))
+                results.append(resync_generator_wrapper(task, resource_config.kind,resource_config.port.items_to_parse))
             else:
                 logger.info(
                     f"Found sync function for {resource_config.kind} name: {task.__qualname__}"
@@ -976,6 +976,11 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             ocean.metrics.initialize_metrics(kinds)
             await ocean.metrics.report_sync_metrics(kinds=kinds, blueprints=blueprints)
 
+            async with metric_resource_context(MetricResourceKind.RUNTIME):
+                ocean.metrics.sync_state = SyncState.SYNCING
+                await ocean.metrics.send_metrics_to_webhook(kind=MetricResourceKind.RUNTIME)
+                await ocean.metrics.report_sync_metrics(kinds=[MetricResourceKind.RUNTIME])
+
             # Clear cache
             await ocean.app.cache_provider.clear()
 
@@ -1010,8 +1015,18 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                 logger.warning(
                     "Resync aborted successfully, skipping delete phase. This leads to an incomplete state"
                 )
+
+                async with metric_resource_context(MetricResourceKind.RUNTIME):
+                    ocean.metrics.sync_state = SyncState.FAILED
+                    await ocean.metrics.send_metrics_to_webhook(kind=MetricResourceKind.RUNTIME)
+                    await ocean.metrics.report_sync_metrics(kinds=[MetricResourceKind.RUNTIME])
                 raise
             else:
+                async with metric_resource_context(MetricResourceKind.RECONCILIATION):
+                    ocean.metrics.sync_state = SyncState.SYNCING
+                    await ocean.metrics.send_metrics_to_webhook(kind=MetricResourceKind.RECONCILIATION)
+                    await ocean.metrics.report_sync_metrics(kinds=[MetricResourceKind.RECONCILIATION])
+
                 success = await self.resync_reconciliation(
                     creation_results,
                     did_fetched_current_state,
@@ -1019,9 +1034,12 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
                     app_config,
                     silent,
                 )
-                await ocean.metrics.report_sync_metrics(
-                    kinds=[MetricResourceKind.RECONCILIATION]
-                )
+
+                async with metric_resource_context(MetricResourceKind.RECONCILIATION):
+                    ocean.metrics.sync_state = SyncState.COMPLETED if success else SyncState.FAILED
+                    await ocean.metrics.send_metrics_to_webhook(kind=MetricResourceKind.RECONCILIATION)
+                    await ocean.metrics.report_sync_metrics(kinds=[MetricResourceKind.RECONCILIATION])
+
                 return success
             finally:
                 await ocean.app.cache_provider.clear()

port_ocean/core/integrations/mixins/utils.py

@@ -1,11 +1,13 @@
 from contextlib import contextmanager
-from typing import Awaitable, Generator, Callable
+from typing import Awaitable, Generator, Callable, cast
 
 from loguru import logger
 
 import asyncio
 import multiprocessing
 
+from port_ocean.core.handlers.entity_processor.jq_entity_processor import JQEntityProcessor
+from port_ocean.core.handlers.port_app_config.models import ResourceConfig
 from port_ocean.core.ocean_types import (
     ASYNC_GENERATOR_RESYNC_TYPE,
     RAW_RESULT,
@@ -49,7 +51,7 @@ async def resync_function_wrapper(
 
 
 async def resync_generator_wrapper(
-    fn: Callable[[str], ASYNC_GENERATOR_RESYNC_TYPE], kind: str
+    fn: Callable[[str], ASYNC_GENERATOR_RESYNC_TYPE], kind: str, items_to_parse: str | None = None
 ) -> ASYNC_GENERATOR_RESYNC_TYPE:
     generator = fn(kind)
     errors = []
@@ -58,7 +60,28 @@ async def resync_generator_wrapper(
             try:
                 with resync_error_handling():
                     result = await anext(generator)
-                    yield validate_result(result)
+                    if not ocean.config.yield_items_to_parse:
+                        yield validate_result(result)
+                    else:
+                        batch_size = ocean.config.yield_items_to_parse_batch_size
+                        if items_to_parse:
+                            for data in result:
+                                items = await cast(JQEntityProcessor, ocean.app.integration.entity_processor)._search(data, items_to_parse)
+                                if not isinstance(items, list):
+                                    logger.warning(
+                                        f"Failed to parse items for JQ expression {items_to_parse}, Expected list but got {type(items)}."
+                                        f" Skipping..."
+                                    )
+                                    yield []
+                                raw_data = [{"item": item, **data} for item in items]
+                                while True:
+                                    raw_data_batch = raw_data[:batch_size]
+                                    yield raw_data_batch
+                                    raw_data = raw_data[batch_size:]
+                                    if len(raw_data) == 0:
+                                        break
+                        else:
+                            yield validate_result(result)
             except OceanAbortException as error:
                 errors.append(error)
                 ocean.metrics.inc_metric(
@@ -97,7 +120,6 @@ class ProcessWrapper(multiprocessing.Process):
             logger.error(f"Process {self.pid} failed with exit code {self.exitcode}")
         else:
             logger.info(f"Process {self.pid} finished with exit code {self.exitcode}")
-        ocean.metrics.cleanup_prometheus_metrics(self.pid)
         return super().join()
 
 def clear_http_client_context() -> None:

port_ocean/helpers/async_client.py

@@ -4,6 +4,7 @@ import httpx
 from loguru import logger
 
 from port_ocean.helpers.retry import RetryTransport
+from port_ocean.helpers.stream import Stream
 
 
 class OceanAsyncClient(httpx.AsyncClient):
@@ -50,3 +51,9 @@ class OceanAsyncClient(httpx.AsyncClient):
             logger=logger,
             **(self._transport_kwargs or {}),
         )
+
+    async def get_stream(self, url: str, **kwargs: Any) -> Stream:
+        req = self.build_request("GET", url, **kwargs)
+        response = await self.send(req, stream=True)
+        response.raise_for_status()
+        return Stream(response)

port_ocean/helpers/metric/metric.py

@@ -1,21 +1,22 @@
 import os
-from typing import Any, TYPE_CHECKING, Optional, Dict, List, Tuple
-from fastapi import APIRouter
-from port_ocean.exceptions.context import ResourceContextNotFoundError
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+
 import prometheus_client
-from httpx import AsyncClient
-from fastapi.responses import PlainTextResponse
-from loguru import logger
-from port_ocean.context import metric_resource, resource
-from prometheus_client import Gauge
 import prometheus_client.openmetrics
 import prometheus_client.openmetrics.exposition
 import prometheus_client.parser
-from prometheus_client import multiprocess
+from fastapi import APIRouter
+from fastapi.responses import PlainTextResponse
+from httpx import AsyncClient
+from loguru import logger
+from prometheus_client import Gauge, multiprocess
+
+from port_ocean.context import metric_resource, resource
+from port_ocean.exceptions.context import ResourceContextNotFoundError
 
 if TYPE_CHECKING:
-    from port_ocean.config.settings import MetricsSettings, IntegrationSettings
     from port_ocean.clients.port.client import PortClient
+    from port_ocean.config.settings import IntegrationSettings, MetricsSettings
 
 
 class MetricPhase:
@@ -61,6 +62,7 @@ class SyncState:
 class MetricResourceKind:
     RECONCILIATION = "__reconciliation__"
     RESYNC = "__resync__"
+    RUNTIME = "__runtime__"
 
 
 # Registry for core and custom metrics
@@ -278,7 +280,7 @@ class Metrics:
         try:
             return metric_resource.metric_resource.metric_resource_kind
         except ResourceContextNotFoundError:
-            return "__runtime__"
+            return MetricResourceKind.RUNTIME
 
     def generate_latest(self) -> str:
         return prometheus_client.openmetrics.exposition.generate_latest(

port_ocean/helpers/stream.py

@@ -0,0 +1,71 @@
+import os
+from typing import Any, AsyncGenerator
+import uuid
+
+import aiofiles
+import httpx
+import ijson  # type: ignore[import-untyped]
+from cryptography.fernet import Fernet
+
+import port_ocean.context.ocean as ocean_context
+
+
+class Stream:
+    def __init__(self, response: httpx.Response):
+        self.response = response
+        self.headers = response.headers
+        self.status_code = response.status_code
+
+    async def _byte_stream(
+        self, chunk_size: int | None = None
+    ) -> AsyncGenerator[bytes, None]:
+        if chunk_size is None:
+            chunk_size = ocean_context.ocean.config.streaming.chunk_size
+
+        file_name = f"{ocean_context.ocean.config.streaming.location}/{uuid.uuid4()}"
+
+        crypt = Fernet(Fernet.generate_key())
+
+        try:
+            async for chunk in self.response.aiter_bytes(chunk_size=chunk_size):
+                async with aiofiles.open(f"{file_name}", "ab") as f:
+                    if len(chunk) > 0:
+                        await f.write(crypt.encrypt(chunk))
+                        await f.write(b"\n")
+        finally:
+            await self.response.aclose()
+
+        try:
+            async with aiofiles.open(f"{file_name}", mode="rb") as f:
+                while True:
+                    line = await f.readline()
+                    if not line:
+                        break
+                    data = crypt.decrypt(line)
+                    yield data
+        finally:
+            try:
+                os.remove(file_name)
+            except FileNotFoundError:
+                pass
+
+    async def get_json_stream(
+        self,
+        target_items: str = "",
+        max_buffer_size_mb: int | None = None,
+    ) -> AsyncGenerator[list[dict[str, Any]], None]:
+        if max_buffer_size_mb is None:
+            max_buffer_size_mb = ocean_context.ocean.config.streaming.max_buffer_size_mb
+
+        events = ijson.sendable_list()
+        coro = ijson.items_coro(events, target_items)
+        current_buffer_size = 0
+        async for chunk in self._byte_stream():
+            coro.send(chunk)
+            current_buffer_size += len(chunk)
+            if current_buffer_size >= max_buffer_size_mb:
+                if len(events) > 0:
+                    yield events
+                    events.clear()
+                    current_buffer_size = 0
+        yield events

port_ocean/log/handlers.py

@@ -3,16 +3,16 @@ import logging
 import sys
 import threading
 import time
+from copy import deepcopy
 from datetime import datetime
 from logging.handlers import MemoryHandler
+from traceback import format_exception
 from typing import Any
 
 from loguru import logger
 
 from port_ocean import Ocean
 from port_ocean.context.ocean import ocean
-from copy import deepcopy
-from traceback import format_exception
 
 
 def _serialize_record(record: logging.LogRecord) -> dict[str, Any]:
@@ -53,7 +53,6 @@ class HTTPMemoryHandler(MemoryHandler):
         return None
 
     def emit(self, record: logging.LogRecord) -> None:
-
         self._serialized_buffer.append(_serialize_record(record))
         super().emit(record)
 
@@ -106,4 +105,4 @@ class HTTPMemoryHandler(MemoryHandler):
         try:
             await _ocean.port_client.ingest_integration_logs(logs_to_send)
         except Exception as e:
-            logger.debug(f"Failed to send logs to Port with error: {e}")
+            logger.error(f"Failed to send logs to Port with error: {e}")

port_ocean/ocean.py

@@ -1,21 +1,18 @@
 import asyncio
 import sys
-from contextlib import asynccontextmanager
 import threading
+from contextlib import asynccontextmanager
 from typing import Any, AsyncIterator, Callable, Dict, Type
 
-from port_ocean.cache.base import CacheProvider
-from port_ocean.cache.disk import DiskCacheProvider
-from port_ocean.cache.memory import InMemoryCacheProvider
-from port_ocean.core.models import ProcessExecutionMode
-import port_ocean.helpers.metric.metric
-
-from fastapi import FastAPI, APIRouter
-
+from fastapi import APIRouter, FastAPI
 from loguru import logger
 from pydantic import BaseModel
 from starlette.types import Receive, Scope, Send
 
+import port_ocean.helpers.metric.metric
+from port_ocean.cache.base import CacheProvider
+from port_ocean.cache.disk import DiskCacheProvider
+from port_ocean.cache.memory import InMemoryCacheProvider
 from port_ocean.clients.port.client import PortClient
 from port_ocean.config.settings import (
     IntegrationConfiguration,
@@ -26,16 +23,17 @@ from port_ocean.context.ocean import (
     ocean,
 )
 from port_ocean.core.handlers.resync_state_updater import ResyncStateUpdater
+from port_ocean.core.handlers.webhook.processor_manager import (
+    LiveEventsProcessorManager,
+)
 from port_ocean.core.integrations.base import BaseIntegration
+from port_ocean.core.models import ProcessExecutionMode
 from port_ocean.log.sensetive import sensitive_log_filter
 from port_ocean.middlewares import request_handler
 from port_ocean.utils.misc import IntegrationStateStatus
 from port_ocean.utils.repeat import repeat_every
 from port_ocean.utils.signal import signal_handler
 from port_ocean.version import __integration_version__
-from port_ocean.core.handlers.webhook.processor_manager import (
-    LiveEventsProcessorManager,
-)
 
 
 class Ocean:
@@ -69,6 +67,7 @@ class Ocean:
             integration_identifier=self.config.integration.identifier,
             integration_type=self.config.integration.type,
             integration_version=__integration_version__,
+            ingest_url=self.config.port.ingest_url,
         )
         self.cache_provider: CacheProvider = self._get_caching_provider()
         self.process_execution_mode: ProcessExecutionMode = (

port_ocean/tests/core/conftest.py

@@ -96,7 +96,13 @@ def mock_http_client() -> MagicMock:
 @pytest.fixture
 def mock_port_client(mock_http_client: MagicMock) -> PortClient:
     mock_port_client = PortClient(
-        MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock()
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
     )
     mock_port_client.auth = AsyncMock()
     mock_port_client.auth.headers = AsyncMock(

port_ocean/tests/core/event_listener/test_kafka.py

@@ -0,0 +1,70 @@
+from port_ocean.core.event_listener.kafka import KafkaEventListenerSettings
+import pytest
+from pydantic import ValidationError
+
+
+def test_default_kafka_settings() -> None:
+    """Test default values are properly set"""
+    config = KafkaEventListenerSettings(type="KAFKA")
+    assert config.type == "KAFKA"
+    assert config.security_protocol == "SASL_SSL"
+    assert config.authentication_mechanism == "SCRAM-SHA-512"
+    assert config.kafka_security_enabled is True
+    assert config.consumer_poll_timeout == 1
+    assert "b-1-public.publicclusterprod" in config.brokers
+
+
+def test_brokers_json_array_parsing() -> None:
+    """Test that JSON array strings get converted to comma-separated"""
+    json_brokers = '["broker1:9092", "broker2:9092", "broker3:9092"]'
+    config = KafkaEventListenerSettings(type="KAFKA", brokers=json_brokers)
+    assert config.brokers == "broker1:9092,broker2:9092,broker3:9092"
+
+
+def test_brokers_regular_string_unchanged() -> None:
+    """Test that regular comma-separated strings pass through unchanged"""
+    regular_brokers = "broker1:9092,broker2:9092"
+    config = KafkaEventListenerSettings(type="KAFKA", brokers=regular_brokers)
+    assert config.brokers == regular_brokers
+
+
+def test_brokers_malformed_json_unchanged() -> None:
+    """Test that malformed JSON strings don't break validation"""
+    bad_json = "[broker1:9092, broker2:9092"
+    config = KafkaEventListenerSettings(type="KAFKA", brokers=bad_json)
+    assert config.brokers == bad_json
+
+
+def test_custom_values() -> None:
+    """Test overriding default values"""
+    config = KafkaEventListenerSettings(
+        type="KAFKA",
+        brokers="custom:9092",
+        security_protocol="PLAINTEXT",
+        authentication_mechanism="PLAIN",
+        kafka_security_enabled=False,
+        consumer_poll_timeout=5,
+    )
+    assert config.brokers == "custom:9092"
+    assert config.security_protocol == "PLAINTEXT"
+    assert config.authentication_mechanism == "PLAIN"
+    assert config.kafka_security_enabled is False
+    assert config.consumer_poll_timeout == 5
+
+
+def test_type_literal_validation() -> None:
+    """Test that type field only accepts KAFKA"""
+    with pytest.raises(ValidationError):
+        KafkaEventListenerSettings(type="RABBITMQ")  # type: ignore[arg-type]
+
+
+def test_empty_brokers_array() -> None:
+    """Test empty JSON array becomes empty string"""
+    config = KafkaEventListenerSettings(type="KAFKA", brokers="[]")
+    assert config.brokers == ""
+
+
+def test_single_broker_array() -> None:
+    """Test single broker in JSON array"""
+    config = KafkaEventListenerSettings(type="KAFKA", brokers='["single:9092"]')
+    assert config.brokers == "single:9092"

port_ocean/tests/core/handlers/entities_state_applier/test_applier.py

@@ -14,8 +14,8 @@ from port_ocean.context.event import event_context, EventType
 
 
 @pytest.mark.asyncio
-async def test_delete_diff_no_deleted_entities() -> None:
-    applier = HttpEntitiesStateApplier(Mock())
+async def test_delete_diff_no_deleted_entities(mock_context: PortOceanContext) -> None:
+    applier = HttpEntitiesStateApplier(mock_context)
     entities = EntityDiff(
         before=[Entity(identifier="1", blueprint="test")],
         after=[Entity(identifier="1", blueprint="test")],

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

@@ -60,7 +60,7 @@ class TestJQEntityProcessor:
         raw_entity_mappings = {"foo": ".foo"}
         selector_query = '.foo == "bar"'
         result, errors = await mocked_processor._calculate_entity(
-            data, raw_entity_mappings, None, selector_query
+            data, raw_entity_mappings, None, "item", selector_query
         )
         assert len(result) == 1
         assert result[0].entity == {"foo": "bar"}

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

@@ -1,7 +1,9 @@
 from typing import Any
-from httpx import Response
-import pytest
 from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from httpx import Response
+
 from port_ocean.clients.port.client import PortClient
 from port_ocean.clients.port.types import UserAgentType
 from port_ocean.context.ocean import PortOceanContext
@@ -11,8 +13,6 @@ from port_ocean.core.handlers.entities_state_applier.port.applier import (
 from port_ocean.core.handlers.entity_processor.jq_entity_processor import (
     JQEntityProcessor,
 )
-from port_ocean.core.handlers.webhook.webhook_event import WebhookEventRawResults
-from port_ocean.core.integrations.mixins.live_events import LiveEventsMixin
 from port_ocean.core.handlers.port_app_config.models import (
     EntityMapping,
     MappingsConfig,
@@ -21,6 +21,8 @@ from port_ocean.core.handlers.port_app_config.models import (
     ResourceConfig,
     Selector,
 )
+from port_ocean.core.handlers.webhook.webhook_event import WebhookEventRawResults
+from port_ocean.core.integrations.mixins.live_events import LiveEventsMixin
 from port_ocean.core.models import Entity
 from port_ocean.core.ocean_types import CalculationResult, EntitySelectorDiff
 from port_ocean.ocean import Ocean
@@ -253,7 +255,13 @@ def mock_port_app_config_handler(
 @pytest.fixture
 def mock_port_client(mock_http_client: MagicMock) -> PortClient:
     mock_port_client = PortClient(
-        MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock()
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
     )
     mock_port_client.auth = AsyncMock()
     mock_port_client.auth.headers = AsyncMock(
@@ -340,10 +348,11 @@ async def test_parse_raw_event_results_to_entities_creation(
         calculation_result
     )
 
-    entities_to_create, entities_to_delete = (
-        await mock_live_events_mixin._parse_raw_event_results_to_entities(
-            [one_webhook_event_raw_results_for_creation]
-        )
+    (
+        entities_to_create,
+        entities_to_delete,
+    ) = await mock_live_events_mixin._parse_raw_event_results_to_entities(
+        [one_webhook_event_raw_results_for_creation]
     )
 
     assert entities_to_create == [entity]
@@ -367,10 +376,11 @@ async def test_parse_raw_event_results_to_entities_deletion(
         calculation_result
     )
 
-    entities_to_create, entities_to_delete = (
-        await mock_live_events_mixin._parse_raw_event_results_to_entities(
-            [one_webhook_event_raw_results_for_deletion]
-        )
+    (
+        entities_to_create,
+        entities_to_delete,
+    ) = await mock_live_events_mixin._parse_raw_event_results_to_entities(
+        [one_webhook_event_raw_results_for_deletion]
     )
 
     assert entities_to_create == []

port_ocean/tests/core/handlers/webhook/test_processor_manager.py

@@ -1,32 +1,16 @@
-import pytest
-from port_ocean.core.handlers.webhook.processor_manager import (
-    LiveEventsProcessorManager,
-)
-from port_ocean.core.handlers.webhook.abstract_webhook_processor import (
-    AbstractWebhookProcessor,
-)
-from port_ocean.core.handlers.webhook.webhook_event import (
-    EventHeaders,
-    WebhookEvent,
-    WebhookEventRawResults,
-    EventPayload,
-)
-from fastapi import APIRouter
-from port_ocean.core.integrations.mixins.handler import HandlerMixin
-from port_ocean.utils.signal import SignalHandler
-from typing import Dict, Any
 import asyncio
+from typing import Any, Dict
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from fastapi import APIRouter, FastAPI
 from fastapi.testclient import TestClient
-from fastapi import FastAPI
-from port_ocean.context.ocean import PortOceanContext
-from unittest.mock import AsyncMock
-from port_ocean.context.event import EventContext, event_context, EventType
-from port_ocean.context.ocean import ocean
-from unittest.mock import MagicMock, patch
 from httpx import Response
-from port_ocean.clients.port.client import PortClient
+
 from port_ocean import Ocean
-from port_ocean.core.integrations.base import BaseIntegration
+from port_ocean.clients.port.client import PortClient
+from port_ocean.context.event import EventContext, EventType, event_context
+from port_ocean.context.ocean import PortOceanContext, ocean
 from port_ocean.core.handlers.port_app_config.models import (
     EntityMapping,
     MappingsConfig,
@@ -35,13 +19,28 @@ from port_ocean.core.handlers.port_app_config.models import (
     ResourceConfig,
     Selector,
 )
+from port_ocean.core.handlers.queue import LocalQueue
+from port_ocean.core.handlers.webhook.abstract_webhook_processor import (
+    AbstractWebhookProcessor,
+)
+from port_ocean.core.handlers.webhook.processor_manager import (
+    LiveEventsProcessorManager,
+)
+from port_ocean.core.handlers.webhook.webhook_event import (
+    EventHeaders,
+    EventPayload,
+    WebhookEvent,
+    WebhookEventRawResults,
+)
+from port_ocean.core.integrations.base import BaseIntegration
+from port_ocean.core.integrations.mixins.handler import HandlerMixin
 from port_ocean.core.integrations.mixins.live_events import LiveEventsMixin
 from port_ocean.core.models import Entity
 from port_ocean.exceptions.webhook_processor import (
     RetryableError,
     WebhookEventNotSupportedError,
 )
-from port_ocean.core.handlers.queue import LocalQueue
+from port_ocean.utils.signal import SignalHandler
 
 
 class MockProcessor(AbstractWebhookProcessor):
@@ -275,7 +274,13 @@ def mock_http_client() -> MagicMock:
 @pytest.fixture
 def mock_port_client(mock_http_client: MagicMock) -> PortClient:
     mock_port_client = PortClient(
-        MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock()
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
+        MagicMock(),
     )
     mock_port_client.auth = AsyncMock()
     mock_port_client.auth.headers = AsyncMock(

port_ocean/tests/helpers/port_client.py

@@ -18,4 +18,5 @@ def get_port_client_for_integration(
         integration_identifier=integration_identifier,
         integration_type=integration_type,
         integration_version=integration_version,
+        ingest_url="https://ingest.getport.io",
     )

{port_ocean-0.27.0.dist-info → port_ocean-0.27.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.27.0
+Version: 0.27.10
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port
@@ -22,12 +22,15 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Provides-Extra: cli
+Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
 Requires-Dist: aiostream (>=0.5.2,<0.7.0)
 Requires-Dist: click (>=8.1.3,<9.0.0) ; extra == "cli"
 Requires-Dist: confluent-kafka (>=2.10.1,<3.0.0)
 Requires-Dist: cookiecutter (>=2.1.1,<3.0.0) ; extra == "cli"
-Requires-Dist: fastapi (>=0.115.3,<0.116.0)
+Requires-Dist: cryptography (>=44.0.1,<45.0.0)
+Requires-Dist: fastapi (>=0.116.0,<0.117.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
+Requires-Dist: ijson (>=3.4.0,<4.0.0)
 Requires-Dist: jinja2 (>=3.1.6)
 Requires-Dist: jinja2-time (>=0.2.0,<0.3.0) ; extra == "cli"
 Requires-Dist: jq (>=1.8.0,<2.0.0)

{port_ocean-0.27.0.dist-info → port_ocean-0.27.10.dist-info}/RECORD

@@ -1,9 +1,9 @@
-integrations/_infra/Dockerfile.Deb,sha256=ovmwNBRNrblTW6K9ru2FNTiT9qDgI7_zY28O__VMW6I,2367
+integrations/_infra/Dockerfile.Deb,sha256=weK3VrskDEsuvYaxerak-XIqDgTx_wPorAFQQjYH_FU,2493
 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=v-K0jgDj5vWyF4HCL8-wluUPB04pf9ycEjusRBmIVnc,1527
+integrations/_infra/Dockerfile.local,sha256=FFX9RvFqlaHvhUrRnnzUl0zQp2oKDFVRGkXJQPMQ7cI,1650
 integrations/_infra/Makefile,sha256=YgLKvuF_Dw4IA7X98Nus6zIW_3cJ60M1QFGs3imj5c4,2430
 integrations/_infra/README.md,sha256=ZtJFSMCTU5zTeM8ddRuW1ZL1ga8z7Ic2F3mxmgOSjgo,1195
 integrations/_infra/entry_local.sh,sha256=Sn2TexTEpruH2ixIAGsk-fZV6Y7pT3jd2Pi9TxBeFuw,633
@@ -56,12 +56,12 @@ port_ocean/clients/auth/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG
 port_ocean/clients/auth/auth_client.py,sha256=scxx7AYqvXoRAd8_K-Ww26oErzi5l8ZCGPc0sVKgIfA,192
 port_ocean/clients/auth/oauth_client.py,sha256=FjexH-T3v4ssRWhkHtvHXhi1EH1Vxu8vwHp3HxqfYN8,795
 port_ocean/clients/port/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/clients/port/authentication.py,sha256=r7r8Ag9WuwXy-CmgeOoj-PHbmJAQxhb2NMx8wrNzF3g,3457
-port_ocean/clients/port/client.py,sha256=dv0mxIOde6J-wFi1FXXZkoNPVHrZzY7RSMhNkDD9xgA,3566
+port_ocean/clients/port/authentication.py,sha256=ZO1Vw1nm-NlVUPPtPS5O4GGDvRmyS3vnayWKyVyuuKc,3519
+port_ocean/clients/port/client.py,sha256=hBXgU0CDseN2F-vn20JqowfVkcd6oSVmYrjn6t4TI6c,3616
 port_ocean/clients/port/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/clients/port/mixins/blueprints.py,sha256=aMCG4zePsMSMjMLiGrU37h5z5_ElfMzTcTvqvOI5wXY,4683
 port_ocean/clients/port/mixins/entities.py,sha256=X2NqH00eK6TMJ3a3QEQRVQlKHzyj5l1FiPkIhonnbPg,24234
-port_ocean/clients/port/mixins/integrations.py,sha256=9G1vo3n9pG1t6siUmPdYtxXbfhGXKhWAWwKHr8x7tU4,11891
+port_ocean/clients/port/mixins/integrations.py,sha256=5OK21zU9vBk1-SuweiQzkXP_VxofVO1cqL7Ipw-X-YM,11940
 port_ocean/clients/port/mixins/migrations.py,sha256=vdL_A_NNUogvzujyaRLIoZEu5vmKDY2BxTjoGP94YzI,1467
 port_ocean/clients/port/mixins/organization.py,sha256=A2cP5V49KnjoAXxjmnm_XGth4ftPSU0qURNfnyUyS_Y,1041
 port_ocean/clients/port/retry_transport.py,sha256=PtIZOAZ6V-ncpVysRUsPOgt8Sf01QLnTKB5YeKBxkJk,1861
@@ -70,7 +70,7 @@ port_ocean/clients/port/utils.py,sha256=osFyAjw7Y5Qf2uVSqC7_RTCQfijiL1zS74JJM0go
 port_ocean/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/config/base.py,sha256=x1gFbzujrxn7EJudRT81C6eN9WsYAb3vOHwcpcpX8Tc,6370
 port_ocean/config/dynamic.py,sha256=Lrk4JRGtR-0YKQ9DDGexX5NGFE7EJ6VoHya19YYhssM,2687
-port_ocean/config/settings.py,sha256=keRT2FJyzQ2G0LNlNP4mqYSwwTjbybL7Ire0oggwScw,7226
+port_ocean/config/settings.py,sha256=pknMyy3T8FP8laCxYNfIIGEjeYFd8kQA1eSPreerBAE,7768
 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
@@ -87,7 +87,7 @@ port_ocean/core/event_listener/__init__.py,sha256=T3E52MKs79fNEW381p7zU9F2vOMvIi
 port_ocean/core/event_listener/base.py,sha256=GFBTHiYhCzps50phzopQFUlTGAluQkCRlyaRqOG4g1Y,2995
 port_ocean/core/event_listener/factory.py,sha256=M4Qi05pI840sjDIbdjUEgYe9Gp5ckoCkX-KgLBxUpZg,4096
 port_ocean/core/event_listener/http.py,sha256=_hkQmi9nNh8YG6hbfLrhkATsmGVO8y3qBWvrBHX5Nhk,2992
-port_ocean/core/event_listener/kafka.py,sha256=pVQfGtElIJN2P5lPBrMxyl05B8c2Q2wp5WvA6Pqjnyc,7501
+port_ocean/core/event_listener/kafka.py,sha256=7bUq4EoVv5sIBxiJnfhi7zdAI7whKoSIaS64Ic9B4Ys,7963
 port_ocean/core/event_listener/once.py,sha256=6DhxQLSz5hjEGhmgLU7aA2ZVRQw3tuwh8sh7N63gRdU,5855
 port_ocean/core/event_listener/polling.py,sha256=iZt59z4Dyus_wVvNfIPbq-G1CozAW9kfPU7uRDLPJVE,3604
 port_ocean/core/event_listener/webhooks_only.py,sha256=PTWnmbLtbJb3ySfotMpTWMYgDVy9zOSYIIGqNbWK0UU,1214
@@ -96,22 +96,22 @@ 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=NsLW35H1dhP5FFD7kHZxA2ndSBcD_-btan7qNWfvWrs,6683
+port_ocean/core/handlers/entities_state_applier/port/applier.py,sha256=xNfDAstW1z9r46BCiuXApeNbEEfel4qfMzB2ssuZJQ8,7010
 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=GxK5BM0yzAoeYTK2-ALKh5qlAe9pebcN7vZfQCZjksM,12787
+port_ocean/core/handlers/entity_processor/jq_entity_processor.py,sha256=qvPMbIH1XRvaZ-TvW7lw9k4W27ZPCHcXGSdqnZ0wblw,12970
 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
-port_ocean/core/handlers/port_app_config/models.py,sha256=pO7oI7GIYZ9c2ZxLu8EQ97U2IPqzsbJf3gRQxlizEjE,2933
+port_ocean/core/handlers/port_app_config/models.py,sha256=M9NJRRacvpZQYCFgHGlRwrdgumbIIJ82WpCyvtOUf5w,3019
 port_ocean/core/handlers/queue/__init__.py,sha256=yzgicE_jAR1wtljFKxgyG6j-HbLcG_Zze5qw1kkALUI,171
 port_ocean/core/handlers/queue/abstract_queue.py,sha256=SaivrYbqg8qsX6wtQlJZyxgcbdMD5B9NZG3byN9AvrI,782
 port_ocean/core/handlers/queue/group_queue.py,sha256=JvvJOwz9z_aI4CjPr7yQX-0rOgqLI5wMdxWk2x5x-34,4989
 port_ocean/core/handlers/queue/local_queue.py,sha256=Y6qabDbrQ8aOPTN6Ct3lnMU7JnT8O8iTpoxMoVt6lFs,643
 port_ocean/core/handlers/resync_state_updater/__init__.py,sha256=kG6y-JQGpPfuTHh912L_bctIDCzAK4DN-d00S7rguWU,81
-port_ocean/core/handlers/resync_state_updater/updater.py,sha256=TRYq6QnTtPlJg6MvgZPtQdZPvkAhkvpcmWjtkxCnkg4,3764
+port_ocean/core/handlers/resync_state_updater/updater.py,sha256=R7K0n-MljKtOFEh2XZKi_fBUOWIdt4X6IZIw-2WMtv0,3813
 port_ocean/core/handlers/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/handlers/webhook/abstract_webhook_processor.py,sha256=5KwZkdkDd5HdVkXPzKiqabodZKl-hOtMypkTKd8Hq3M,3891
 port_ocean/core/handlers/webhook/processor_manager.py,sha256=0KRPD1ae-7w0na2AZY-rq9_gY0IaMv9LdwEh6y4_OiQ,13282
@@ -123,8 +123,8 @@ 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=6AHuroSoqIKvdx2BAKtILxfQFeYB_wikYaM4JaTeoGw,39315
-port_ocean/core/integrations/mixins/utils.py,sha256=N76dNu1Y6UEg0_pcSdF4RO6dQIZ8EBfX3xMelgWdMxM,3779
+port_ocean/core/integrations/mixins/sync_raw.py,sha256=50tklPFBYvVoucIcCx1yYU-gwzliXCOX7kJP6_dgsNI,40631
+port_ocean/core/integrations/mixins/utils.py,sha256=ytnFX7Lyv6N3CgBnOXxYaI1cRDq5Z4NDrVFiwE6bn-M,5250
 port_ocean/core/models.py,sha256=DNbKpStMINI2lIekKprTqBevqkw_wFuFayN19w1aDfQ,2893
 port_ocean/core/ocean_types.py,sha256=bkLlTd8XfJK6_JDl0eXUHfE_NygqgiInSMwJ4YJH01Q,1399
 port_ocean/core/utils/entity_topological_sorter.py,sha256=MDUjM6OuDy4Xj68o-7InNN0w1jqjxeDfeY8U02vySNI,3081
@@ -140,16 +140,17 @@ port_ocean/exceptions/port_defaults.py,sha256=2a7Koy541KxMan33mU-gbauUxsumG3NT4i
 port_ocean/exceptions/utils.py,sha256=gjOqpi-HpY1l4WlMFsGA9yzhxDhajhoGGdDDyGbLnqI,197
 port_ocean/exceptions/webhook_processor.py,sha256=4SnkVzVwiacH_Ip4qs1hRHa6GanhnojW_TLTdQQtm7Y,363
 port_ocean/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/helpers/async_client.py,sha256=0MkFY46MuEYkju7gJ8HYeUTMBsjwAzESvATryJy2DaM,1698
-port_ocean/helpers/metric/metric.py,sha256=Aacz7bOd8ZCwEPpXAdwLbKRXf28Z4wiViG_GXiV_xWg,14529
+port_ocean/helpers/async_client.py,sha256=LOgUlZ5Cs_WUSc8XujCVjPGvzZ_3AuFJNKPy0FKV3fA,1987
+port_ocean/helpers/metric/metric.py,sha256=-dw7-Eqr65AZwv0M-xPaAk98g_JS16ICBc9_UkycFbE,14543
 port_ocean/helpers/metric/utils.py,sha256=1lAgrxnZLuR_wUNDyPOPzLrm32b8cDdioob2lvnPQ1A,1619
 port_ocean/helpers/retry.py,sha256=VHAp6j9-Vid6aNR5sca3S0aW6b1S2oYw9vT9hi1N22U,18556
+port_ocean/helpers/stream.py,sha256=_UwsThzXynxWzL8OlBT1pmb2evZBi9HaaqeAGNuTuOI,2338
 port_ocean/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/log/handlers.py,sha256=ncVjgqrZRh6BhyRrA6DQG86Wsbxph1yWYuEC0cWfe-Q,3631
+port_ocean/log/handlers.py,sha256=LJ1WAfq7wYCrBpeLPihMKmWjdSahKKXNHFMRYkbk0Co,3630
 port_ocean/log/logger_setup.py,sha256=0K3zVG0YYrYOWEV8-rCGks1o-bMRxgHXlqawu9w_tSw,2656
 port_ocean/log/sensetive.py,sha256=lVKiZH6b7TkrZAMmhEJRhcl67HNM94e56x12DwFgCQk,2920
 port_ocean/middlewares.py,sha256=9wYCdyzRZGK1vjEJ28FY_DkfwDNENmXp504UKPf5NaQ,2727
-port_ocean/ocean.py,sha256=83zgTEI5o2wfl8mq-iIC9DzPOZbWyCqNIy1BEjv9TOk,8824
+port_ocean/ocean.py,sha256=IhsLnPqEJ2SflnBAt-byxGl9w_ULkdvd6-sxBbVQtJw,8874
 port_ocean/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/run.py,sha256=CmKz14bxfdOooNbQ5QqH1MwX-XLYVG4NgT4KbrzFaqI,2216
 port_ocean/sonar-project.properties,sha256=X_wLzDOkEVmpGLRMb2fg9Rb0DxWwUFSvESId8qpvrPI,73
@@ -165,18 +166,19 @@ port_ocean/tests/clients/port/mixins/test_integrations.py,sha256=vRt_EMsLozQC1LJ
 port_ocean/tests/clients/port/mixins/test_organization_mixin.py,sha256=zzKYz3h8dl4Z5A2QG_924m0y9U6XTth1XYOfwNrd_24,914
 port_ocean/tests/config/test_config.py,sha256=Rk4N-ldVSOfn1p23NzdVdfqUpPrqG2cMut4Sv-sAOrw,1023
 port_ocean/tests/conftest.py,sha256=JXASSS0IY0nnR6bxBflhzxS25kf4iNaABmThyZ0mZt8,101
-port_ocean/tests/core/conftest.py,sha256=5shShx81LRuQTBwS2sDIjNJO2LSD6cUNz46SgNYzjGY,7686
+port_ocean/tests/core/conftest.py,sha256=0Oql7R1iTbjPyNdUoO6M21IKknLwnCIgDRz2JQ7nf0w,7748
 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=AyzLclJFKz8YzSi2hiFYVdXRzCFmqQwTxnwNFTo9roU,14091
-port_ocean/tests/core/handlers/mixins/test_live_events.py,sha256=6yUsYooBYchiZP_eYa8PN1IhiztJShBdPguoseyNMzY,12482
+port_ocean/tests/core/event_listener/test_kafka.py,sha256=PH90qk2fvdrQOSZD2QrvkGy8w_WoYb_KHGnqJ6PLHAo,2681
+port_ocean/tests/core/handlers/entities_state_applier/test_applier.py,sha256=7XWgwUB9uVYRov4VbIz1A-7n2YLbHTTYT-4rKJxjB0A,10711
+port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py,sha256=TjSj8ssIqH23VJlO5PGovbudCqDbuE2-54iNQsD9K-I,14099
+port_ocean/tests/core/handlers/mixins/test_live_events.py,sha256=Sbv9IZAGQoZDhf27xDjMMVYxUSie9mHltDtxLSqckmM,12548
 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_group_queue.py,sha256=Y1BrQi5xwhk5bYDlKRWw9PenF5cqxIF2TIU_hldqji0,22801
 port_ocean/tests/core/handlers/queue/test_local_queue.py,sha256=9Ly0HzZXbs6Rbl_bstsIdInC3h2bgABU3roP9S_PnJM,2582
 port_ocean/tests/core/handlers/webhook/test_abstract_webhook_processor.py,sha256=zKwHhPAYEZoZ5Z2UETp1t--mbkS8uyvlXThB0obZTTc,3340
-port_ocean/tests/core/handlers/webhook/test_processor_manager.py,sha256=rqNFc-S_ZnPyDTSFTdiGcRFKbeDGfWQCH_f2UPbfcAA,52310
+port_ocean/tests/core/handlers/webhook/test_processor_manager.py,sha256=16q-5NagXBv8J1TZC75h-9N4MW_8KB4GX2mmPD6gr4s,52294
 port_ocean/tests/core/handlers/webhook/test_webhook_event.py,sha256=oR4dEHLO65mp6rkfNfszZcfFoRZlB8ZWee4XetmsuIk,3181
 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
@@ -186,7 +188,7 @@ port_ocean/tests/helpers/fake_port_api.py,sha256=9rtjC6iTQMfzWK6WipkDzzG0b1IIaRm
 port_ocean/tests/helpers/fixtures.py,sha256=dinEucKDTGAD2tKwbOqqHZSHNPsDLN2HxnLqA-WXGeI,1443
 port_ocean/tests/helpers/integration.py,sha256=_RxS-RHpu11lrbhUXYPZp862HLWx8AoD7iZM6iXN8rs,1104
 port_ocean/tests/helpers/ocean_app.py,sha256=N06vcNI1klqdcNFq-PXL5vm77u-hODsOSXnj9p8d1AI,2249
-port_ocean/tests/helpers/port_client.py,sha256=5d6GNr8vNNSOkrz1AdOhxBUKuusr_-UPDP7AVpHasQw,599
+port_ocean/tests/helpers/port_client.py,sha256=S0CXvZWUoHFWWQUOEgdkDammK9Fs3R06wx0flaMrTsg,647
 port_ocean/tests/helpers/smoke_test.py,sha256=_9aJJFRfuGJEg2D2YQJVJRmpreS6gEPHHQq8Q01x4aQ,2697
 port_ocean/tests/log/test_handlers.py,sha256=x2P2Hd6Cb3sQafIE3TRGltbbHeiFHaiEjwRn9py_03g,2165
 port_ocean/tests/test_metric.py,sha256=gDdeJcqJDQ_o3VrYrW23iZyw2NuUsyATdrygSXhcDuQ,8096
@@ -205,8 +207,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.27.0.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.27.0.dist-info/METADATA,sha256=dWJb3IOgu_hp6Q1I5G4VxB3b31owoTzF7xSSgSpsGAM,6887
-port_ocean-0.27.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.27.0.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.27.0.dist-info/RECORD,,
+port_ocean-0.27.10.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.27.10.dist-info/METADATA,sha256=Igj6QUVBOykcFVAw94SzlNlVos1FrGhIAINmZnLK1GM,7016
+port_ocean-0.27.10.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.27.10.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.27.10.dist-info/RECORD,,