port-ocean 0.9.14__py3-none-any.whl → 0.10.0__py3-none-any.whl

port_ocean/clients/port/client.py

@@ -13,6 +13,7 @@ from port_ocean.clients.port.utils import (
     get_internal_http_client,
 )
 from port_ocean.exceptions.clients import KafkaCredentialsNotFound
+from typing import Any
 
 
 class PortClient(
@@ -75,3 +76,19 @@ class PortClient(
         handle_status_code(response)
 
         return response.json()["organization"]["id"]
+
+    async def update_integration_state(
+        self, state: dict[str, Any], should_raise: bool = True, should_log: bool = True
+    ) -> dict[str, Any]:
+        if should_log:
+            logger.debug(f"Updating integration resync state with: {state}")
+        response = await self.client.patch(
+            f"{self.api_url}/integration/{self.integration_identifier}/resync-state",
+            headers=await self.auth.headers(),
+            json=state,
+        )
+        handle_status_code(response, should_raise, should_log)
+        if response.is_success and should_log:
+            logger.info("Integration resync state updated successfully")
+
+        return response.json().get("integration", {})

port_ocean/config/settings.py

@@ -76,7 +76,7 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     integration: IntegrationSettings = Field(
         default_factory=lambda: IntegrationSettings(type="", identifier="")
     )
-    runtime: Runtime = "OnPrem"
+    runtime: Runtime = Runtime.OnPrem
 
     @root_validator()
     def validate_integration_config(cls, values: dict[str, Any]) -> dict[str, Any]:
@@ -100,8 +100,8 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
         return values
 
     @validator("runtime")
-    def validate_runtime(cls, runtime: Literal["OnPrem", "Saas"]) -> Runtime:
-        if runtime == "Saas":
+    def validate_runtime(cls, runtime: Runtime) -> Runtime:
+        if runtime == Runtime.Saas:
             spec = get_spec_file()
             if spec is None:
                 raise ValueError(

port_ocean/core/event_listener/base.py

@@ -5,6 +5,8 @@ from pydantic import Extra
 
 from port_ocean.config.base import BaseOceanModel
 from port_ocean.utils.signal import signal_handler
+from port_ocean.context.ocean import ocean
+from port_ocean.utils.misc import IntegrationStateStatus
 
 
 class EventListenerEvents(TypedDict):
@@ -36,6 +38,41 @@ class BaseEventListener:
         """
         pass
 
+    async def _before_resync(self) -> None:
+        """
+        Can be used for event listeners that need to perform some action before resync.
+        """
+        await ocean.app.resync_state_updater.update_before_resync()
+
+    async def _after_resync(self) -> None:
+        """
+        Can be used for event listeners that need to perform some action after resync.
+        """
+        await ocean.app.resync_state_updater.update_after_resync()
+
+    async def _on_resync_failure(self, e: Exception) -> None:
+        """
+        Can be used for event listeners that need to handle resync failures.
+        """
+        await ocean.app.resync_state_updater.update_after_resync(
+            IntegrationStateStatus.Failed
+        )
+
+    async def _resync(
+        self,
+        resync_args: dict[Any, Any],
+    ) -> None:
+        """
+        Triggers the "on_resync" event.
+        """
+        await self._before_resync()
+        try:
+            await self.events["on_resync"](resync_args)
+            await self._after_resync()
+        except Exception as e:
+            await self._on_resync_failure(e)
+            raise e
+
 
 class EventListenerSettings(BaseOceanModel, extra=Extra.allow):
     type: str

port_ocean/core/event_listener/http.py

@@ -64,6 +64,6 @@ class HttpEventListener(BaseEventListener):
 
         @target_channel_router.post("/resync")
         async def resync() -> None:
-            await self.events["on_resync"]({})
+            await self._resync({})
 
         ocean.app.fast_api_app.include_router(target_channel_router)

port_ocean/core/event_listener/kafka.py

@@ -99,9 +99,13 @@ class KafkaEventListener(BaseEventListener):
             return False
 
         integration_identifier = after.get("identifier")
-        if integration_identifier == self.integration_identifier and (
-            "change.log" in topic
-        ):
+        if integration_identifier != self.integration_identifier:
+            return False
+
+        if after.get("updatedAt") == after.get("resyncState", {}).get("updatedAt"):
+            return False
+
+        if "change.log" in topic:
             return msg_value.get("changelogDestination", {}).get("type", "") == "KAFKA"
 
         return False
@@ -122,7 +126,7 @@ class KafkaEventListener(BaseEventListener):
 
         if "change.log" in topic and message is not None:
             try:
-                await self.events["on_resync"](message)
+                await self._resync(message)
             except Exception as e:
                 _type, _, tb = sys.exc_info()
                 logger.opt(exception=(_type, None, tb)).error(

port_ocean/core/event_listener/once.py

@@ -1,3 +1,4 @@
+import datetime
 import signal
 from typing import Literal, Any
 
@@ -9,6 +10,9 @@ from port_ocean.core.event_listener.base import (
     EventListenerSettings,
 )
 from port_ocean.utils.repeat import repeat_every
+from port_ocean.context.ocean import ocean
+from port_ocean.utils.time import convert_str_to_utc_datetime, convert_to_minutes
+from port_ocean.utils.misc import IntegrationStateStatus
 
 
 class OnceEventListenerSettings(EventListenerSettings):
@@ -41,6 +45,97 @@ class OnceEventListener(BaseEventListener):
     ):
         super().__init__(events)
         self.event_listener_config = event_listener_config
+        self.cached_integration: dict[str, Any] | None = None
+
+    async def get_current_integration_cached(self) -> dict[str, Any]:
+        if self.cached_integration:
+            return self.cached_integration
+
+        self.cached_integration = await ocean.port_client.get_current_integration()
+        return self.cached_integration
+
+    async def get_saas_resync_initialization_and_interval(
+        self,
+    ) -> tuple[int | None, datetime.datetime | None]:
+        """
+        Get the scheduled resync interval and the last updated time of the integration config for the saas application.
+        interval is the saas configured resync interval time.
+        start_time is the last updated time of the integration config.
+        return: (interval, start_time)
+        """
+        if not ocean.app.is_saas():
+            return (None, None)
+
+        try:
+            integration = await self.get_current_integration_cached()
+        except Exception as e:
+            logger.exception(f"Error occurred while getting current integration {e}")
+            return (None, None)
+
+        interval_str = (
+            integration.get("spec", {})
+            .get("appSpec", {})
+            .get("scheduledResyncInterval")
+        )
+
+        if not interval_str:
+            logger.error(
+                "Unexpected: scheduledResyncInterval not found for Saas integration, Cannot predict the next resync"
+            )
+            return (None, None)
+
+        last_updated_saas_integration_config_str = integration.get(
+            "statusInfo", {}
+        ).get("updatedAt")
+
+        # we use the last updated time of the integration config as the start time since in saas application the interval is configured by the user from the portal
+        if not last_updated_saas_integration_config_str:
+            logger.error(
+                "Unexpected: updatedAt not found for Saas integration, Cannot predict the next resync"
+            )
+            return (None, None)
+
+        return (
+            convert_to_minutes(interval_str),
+            convert_str_to_utc_datetime(last_updated_saas_integration_config_str),
+        )
+
+    async def _before_resync(self) -> None:
+        if not ocean.app.is_saas():
+            # in case of non-saas, we still want to update the state before and after the resync
+            await super()._before_resync()
+            return
+
+        (interval, start_time) = (
+            await self.get_saas_resync_initialization_and_interval()
+        )
+        await ocean.app.resync_state_updater.update_before_resync(interval, start_time)
+
+    async def _after_resync(self) -> None:
+        if not ocean.app.is_saas():
+            # in case of non-saas, we still want to update the state before and after the resync
+            await super()._after_resync()
+            return
+
+        (interval, start_time) = (
+            await self.get_saas_resync_initialization_and_interval()
+        )
+        await ocean.app.resync_state_updater.update_after_resync(
+            IntegrationStateStatus.Completed, interval, start_time
+        )
+
+    async def _on_resync_failure(self, e: Exception) -> None:
+        if not ocean.app.is_saas():
+            # in case of non-saas, we still want to update the state before and after the resync
+            await super()._after_resync()
+            return
+
+        (interval, start_time) = (
+            await self.get_saas_resync_initialization_and_interval()
+        )
+        await ocean.app.resync_state_updater.update_after_resync(
+            IntegrationStateStatus.Failed, interval, start_time
+        )
 
     async def _start(self) -> None:
         """
@@ -53,7 +148,7 @@ class OnceEventListener(BaseEventListener):
         async def resync_and_exit() -> None:
             logger.info("Once event listener started")
             try:
-                await self.events["on_resync"]({})
+                await self._resync({})
             except Exception:
                 # we catch all exceptions here to make sure the application will exit gracefully
                 logger.exception("Error occurred while resyncing")

port_ocean/core/event_listener/polling.py

@@ -49,7 +49,16 @@ class PollingEventListener(BaseEventListener):
     ):
         super().__init__(events)
         self.event_listener_config = event_listener_config
-        self._last_updated_at = None
+
+    def should_resync(self, last_updated_at: str) -> bool:
+        _last_updated_at = (
+            ocean.app.resync_state_updater.last_integration_state_updated_at
+        )
+
+        if _last_updated_at is None:
+            return self.event_listener_config.resync_on_start
+
+        return _last_updated_at != last_updated_at
 
     async def _start(self) -> None:
         """
@@ -69,17 +78,12 @@ class PollingEventListener(BaseEventListener):
             integration = await ocean.app.port_client.get_current_integration()
             last_updated_at = integration["updatedAt"]
 
-            should_resync = (
-                self._last_updated_at is not None
-                or self.event_listener_config.resync_on_start
-            ) and self._last_updated_at != last_updated_at
-
-            if should_resync:
+            if self.should_resync(last_updated_at):
                 logger.info("Detected change in integration, resyncing")
-                self._last_updated_at = last_updated_at
-                running_task: Task[Any] = get_event_loop().create_task(
-                    self.events["on_resync"]({})  # type: ignore
+                ocean.app.resync_state_updater.last_integration_state_updated_at = (
+                    last_updated_at
                 )
+                running_task: Task[Any] = get_event_loop().create_task(self._resync({}))
                 signal_handler.register(running_task.cancel)
 
                 await running_task

port_ocean/core/handlers/resync_state_updater/__init__.py

@@ -0,0 +1,5 @@
+from .updater import ResyncStateUpdater
+
+__all__ = [
+    "ResyncStateUpdater",
+]

port_ocean/core/handlers/resync_state_updater/updater.py

@@ -0,0 +1,84 @@
+import datetime
+from typing import Any, Literal
+from port_ocean.clients.port.client import PortClient
+from port_ocean.utils.misc import IntegrationStateStatus
+from port_ocean.utils.time import get_next_occurrence
+
+
+class ResyncStateUpdater:
+    def __init__(self, port_client: PortClient, scheduled_resync_interval: int | None):
+        self.port_client = port_client
+        self.initiated_at = datetime.datetime.now(tz=datetime.timezone.utc)
+        self.scheduled_resync_interval = scheduled_resync_interval
+
+        # This is used to differ between integration changes that require a full resync and state changes
+        # So that the polling event-listener can decide whether to perform a full resync or not
+        # TODO: remove this once we separate the state from the integration
+        self.last_integration_state_updated_at: str = ""
+
+    def _calculate_next_scheduled_resync(
+        self,
+        interval: int | None = None,
+        custom_start_time: datetime.datetime | None = None,
+    ) -> str | None:
+        if interval is None:
+            return None
+        return get_next_occurrence(
+            interval * 60, custom_start_time or self.initiated_at
+        ).isoformat()
+
+    async def update_before_resync(
+        self,
+        interval: int | None = None,
+        custom_start_time: datetime.datetime | None = None,
+    ) -> None:
+        _interval = interval or self.scheduled_resync_interval
+        nest_resync = self._calculate_next_scheduled_resync(
+            _interval, custom_start_time
+        )
+        state: dict[str, Any] = {
+            "status": IntegrationStateStatus.Running.value,
+            "lastResyncEnd": None,
+            "lastResyncStart": datetime.datetime.now(
+                tz=datetime.timezone.utc
+            ).isoformat(),
+            "nextResync": nest_resync,
+            "intervalInMinuets": _interval,
+        }
+
+        integration = await self.port_client.update_integration_state(
+            state, should_raise=False
+        )
+        if integration:
+            self.last_integration_state_updated_at = integration["resyncState"][
+                "updatedAt"
+            ]
+
+    async def update_after_resync(
+        self,
+        status: Literal[
+            IntegrationStateStatus.Completed, IntegrationStateStatus.Failed
+        ] = IntegrationStateStatus.Completed,
+        interval: int | None = None,
+        custom_start_time: datetime.datetime | None = None,
+    ) -> None:
+        _interval = interval or self.scheduled_resync_interval
+        nest_resync = self._calculate_next_scheduled_resync(
+            _interval, custom_start_time
+        )
+        state: dict[str, Any] = {
+            "status": status.value,
+            "lastResyncEnd": datetime.datetime.now(
+                tz=datetime.timezone.utc
+            ).isoformat(),
+            "nextResync": nest_resync,
+            "intervalInMinuets": _interval,
+        }
+
+        integration = await self.port_client.update_integration_state(
+            state, should_raise=False
+        )
+        if integration:
+            self.last_integration_state_updated_at = integration["resyncState"][
+                "updatedAt"
+            ]

port_ocean/core/models.py

@@ -1,11 +1,14 @@
 from dataclasses import dataclass, field
-from typing import Any, Literal
+from enum import Enum
+from typing import Any
 
 from pydantic import BaseModel
 from pydantic.fields import Field
 
 
-Runtime = Literal["OnPrem", "Saas"]
+class Runtime(Enum):
+    Saas = "Saas"
+    OnPrem = "OnPrem"
 
 
 class Entity(BaseModel):

port_ocean/core/utils.py

@@ -35,12 +35,13 @@ def is_same_entity(first_entity: Entity, second_entity: Entity) -> bool:
 
 
 async def validate_integration_runtime(
-    port_client: PortClient, requested_runtime: Runtime
+    port_client: PortClient,
+    requested_runtime: Runtime,
 ) -> None:
     logger.debug("Validating integration runtime")
     current_integration = await port_client.get_current_integration(should_raise=False)
     current_runtime = current_integration.get("installationType", "OnPrem")
-    if current_integration and current_runtime != requested_runtime:
+    if current_integration and current_runtime != requested_runtime.value:
         raise IntegrationRuntimeException(
             f"Invalid Runtime! Requested to run existing {current_runtime} integration in {requested_runtime} runtime."
         )

port_ocean/ocean.py

@@ -9,6 +9,8 @@ from loguru import logger
 from pydantic import BaseModel
 from starlette.types import Scope, Receive, Send
 
+from port_ocean.core.handlers.resync_state_updater import ResyncStateUpdater
+from port_ocean.core.models import Runtime
 from port_ocean.clients.port.client import PortClient
 from port_ocean.config.settings import (
     IntegrationConfiguration,
@@ -24,6 +26,7 @@ from port_ocean.middlewares import request_handler
 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.utils.misc import IntegrationStateStatus
 
 
 class Ocean:
@@ -63,16 +66,27 @@ class Ocean:
             integration_class(ocean) if integration_class else BaseIntegration(ocean)
         )
 
+        self.resync_state_updater = ResyncStateUpdater(
+            self.port_client, self.config.scheduled_resync_interval
+        )
+
+    def is_saas(self) -> bool:
+        return self.config.runtime == Runtime.Saas
+
     async def _setup_scheduled_resync(
         self,
     ) -> None:
-        def execute_resync_all() -> None:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
+        async def execute_resync_all() -> None:
+            await self.resync_state_updater.update_before_resync()
             logger.info("Starting a new scheduled resync")
-            loop.run_until_complete(self.integration.sync_raw_all())
-            loop.close()
+            try:
+                await self.integration.sync_raw_all()
+                await self.resync_state_updater.update_after_resync()
+            except Exception as e:
+                await self.resync_state_updater.update_after_resync(
+                    IntegrationStateStatus.Failed
+                )
+                raise e
 
         interval = self.config.scheduled_resync_interval
         if interval is not None:
@@ -83,7 +97,11 @@ class Ocean:
                 seconds=interval * 60,
                 # Not running the resync immediately because the event listener should run resync on startup
                 wait_first=True,
-            )(lambda: threading.Thread(target=execute_resync_all).start())
+            )(
+                lambda: threading.Thread(
+                    target=lambda: asyncio.run(execute_resync_all())
+                ).start()
+            )
             await repeated_function()
 
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:

port_ocean/utils/misc.py

@@ -1,3 +1,4 @@
+from enum import Enum
 import inspect
 from importlib.util import spec_from_file_location, module_from_spec
 from pathlib import Path
@@ -5,11 +6,16 @@ from time import time
 from types import ModuleType
 from typing import Callable, Any
 from uuid import uuid4
-
 import tomli
 import yaml
 
 
+class IntegrationStateStatus(Enum):
+    Running = "running"
+    Failed = "failed"
+    Completed = "completed"
+
+
 def get_time(seconds_precision: bool = True) -> float:
     """Return current time as Unix/Epoch timestamp, in seconds.
     :param seconds_precision: if True, return with seconds precision as integer (default).

port_ocean/utils/time.py

@@ -0,0 +1,54 @@
+import datetime
+from loguru import logger
+
+
+def convert_str_to_utc_datetime(time_str: str) -> datetime.datetime | None:
+    """
+    Convert a string representing time to a datetime object.
+    :param time_str: a string representing time in the format "2021-09-01T12:00:00Z"
+    """
+    aware_date = datetime.datetime.fromisoformat(time_str)
+    if time_str.endswith("Z"):
+        aware_date = datetime.datetime.fromisoformat(time_str.replace("Z", "+00:00"))
+    return aware_date.astimezone(datetime.timezone.utc)
+
+
+def convert_to_minutes(s: str) -> int:
+    minutes_per_unit = {"s": 1 / 60, "m": 1, "h": 60, "d": 1440, "w": 10080}
+    try:
+        return int(int(s[:-1]) * minutes_per_unit[s[-1]])
+    except Exception:
+        logger.error(f"Failed converting string to minutes, {s}")
+        raise ValueError(
+            f"Invalid format. Expected a string ending with {minutes_per_unit.keys()}"
+        )
+
+
+def get_next_occurrence(
+    interval_seconds: int,
+    start_time: datetime.datetime,
+    now: datetime.datetime | None = None,
+) -> datetime.datetime:
+    """
+    Predict the next occurrence of an event based on interval, start time, and current time.
+
+    :param interval_minutes: Interval between occurrences in minutes.
+    :param start_time: Start time of the event as a datetime object.
+    :param now: Current time as a datetime object.
+    :return: The next occurrence time as a datetime object.
+    """
+
+    if now is None:
+        now = datetime.datetime.now(tz=datetime.timezone.utc)
+    # Calculate the total seconds elapsed since the start time
+    elapsed_seconds = (now - start_time).total_seconds()
+
+    # Calculate the number of intervals that have passed
+    intervals_passed = int(elapsed_seconds // interval_seconds)
+
+    # Calculate the next occurrence time
+    next_occurrence = start_time + datetime.timedelta(
+        seconds=(intervals_passed + 1) * interval_seconds
+    )
+
+    return next_occurrence

{port_ocean-0.9.14.dist-info → port_ocean-0.10.0.dist-info}/METADATA

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

@@ -37,7 +37,7 @@ port_ocean/cli/utils.py,sha256=IUK2UbWqjci-lrcDdynZXqVP5B5TcjF0w5CpEVUks-k,54
 port_ocean/clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/clients/port/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/clients/port/authentication.py,sha256=t3z6h4vld-Tzkpth15sstaMJg0rccX-pXXjNtOa-nCY,2949
-port_ocean/clients/port/client.py,sha256=3GYCM0ZkX3pB6sNoOb-7_6dm0Jr5_vqhflD9iltf_As,2640
+port_ocean/clients/port/client.py,sha256=Xd8Jk25Uh4WXY_WW-z1Qbv6F3ZTBFPoOolsxHMfozKw,3366
 port_ocean/clients/port/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/clients/port/mixins/blueprints.py,sha256=8ZVC5i8K1WKQMJJiPqZmgcOlF3OyxWz1aAQ_WA5UW3c,4500
 port_ocean/clients/port/mixins/entities.py,sha256=j3YqLb1zMmJrIutYsYsZ_WCT4xh9VXEIH1A0kYMUUtk,8104
@@ -49,7 +49,7 @@ port_ocean/clients/port/utils.py,sha256=O9mBu6zp4TfpS4SQ3qCPpn9ZVyYF8GKnji4UnYhM
 port_ocean/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/config/base.py,sha256=x1gFbzujrxn7EJudRT81C6eN9WsYAb3vOHwcpcpX8Tc,6370
 port_ocean/config/dynamic.py,sha256=qOFkRoJsn_BW7581omi_AoMxoHqasf_foxDQ_G11_SI,2030
-port_ocean/config/settings.py,sha256=uAch5C-1FrRdWAtwGZvbUROfnmTc83gculpTBfpNAG0,4193
+port_ocean/config/settings.py,sha256=EguKa8idZWylil_dQucip6W_q4_WzfTr4_XQjtyE4ds,4187
 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
@@ -62,12 +62,12 @@ port_ocean/core/defaults/clean.py,sha256=S3UAfca-oU89WJKIB4OgGjGjPr0vxBQ2aRZsLTZ
 port_ocean/core/defaults/common.py,sha256=uVUg6VEn4RqtXQwLwMNGfkmT5zYRN_h5USfKw3poVyo,3561
 port_ocean/core/defaults/initialize.py,sha256=U1JWdpG_snAyqBXEikCjA7JzL7UtpOyx5rLfPhrBIZk,8721
 port_ocean/core/event_listener/__init__.py,sha256=mzJ33wRq0kh60fpVdOHVmvMTUQIvz3vxmifyBgwDn0E,889
-port_ocean/core/event_listener/base.py,sha256=4RujgPz4VfDFlviu4qLGJFnJougSCL-Ewf0rfTQfwgc,1133
+port_ocean/core/event_listener/base.py,sha256=1Nmpg00OfT2AD2L8eFm4VQEcdG2TClpSWJMhWhAjkEE,2356
 port_ocean/core/event_listener/factory.py,sha256=AYYfSHPAF7P5H-uQECXT0JVJjKDHrYkWJJBSL4mGkg8,3697
-port_ocean/core/event_listener/http.py,sha256=UjONC_OODHjpGjvsBPAvO6zGzosdmv5Hx96B4WFqpXs,2577
-port_ocean/core/event_listener/kafka.py,sha256=0U_TwmlmtS8N2lprkCmnyOmdqOAvghWxHhSfyu46kEs,6875
-port_ocean/core/event_listener/once.py,sha256=KdvUqjIcyp8XqhY1GfR_KYJfParFIRrjCtcMf3JMegk,2150
-port_ocean/core/event_listener/polling.py,sha256=3UxjgQJly5y-hA8R798oFWb7bFsYMxSc6GRozA3biiM,3539
+port_ocean/core/event_listener/http.py,sha256=N8HrfFqR3KGKz96pWdp_pP-m30jGtcz_1CkijovkBN8,2565
+port_ocean/core/event_listener/kafka.py,sha256=ulidnp4sz-chXwHsbH9JayVjcxy_mG6ts_Im3YKmLpI,6983
+port_ocean/core/event_listener/once.py,sha256=iL3NkujZOw-7LpxT-EAUJUcAuiAZPm4ZzjHTSt9EdHs,5918
+port_ocean/core/event_listener/polling.py,sha256=d9E3oRLy-Ogb0oadZNxSDgSLIHe4z92uMVwztscZycg,3667
 port_ocean/core/handlers/__init__.py,sha256=d7ShmS90gLRzGKJA6oNy2Zs_dF2yjkmYZInRhBnO9Rw,572
 port_ocean/core/handlers/base.py,sha256=cTarblazu8yh8xz2FpB-dzDKuXxtoi143XJgPbV_DcM,157
 port_ocean/core/handlers/entities_state_applier/__init__.py,sha256=kgLZDCeCEzi4r-0nzW9k78haOZNf6PX7mJOUr34A4c8,173
@@ -83,6 +83,8 @@ port_ocean/core/handlers/port_app_config/__init__.py,sha256=8AAT5OthiVM7KCcM34iE
 port_ocean/core/handlers/port_app_config/api.py,sha256=6VbKPwFzsWG0IYsVD81hxSmfqtHUFqrfUuj1DBX5g4w,853
 port_ocean/core/handlers/port_app_config/base.py,sha256=4Nxt2g8voEIHJ4Y1Km5NJcaG2iSbCklw5P8-Kus7Y9k,3007
 port_ocean/core/handlers/port_app_config/models.py,sha256=4dw6HbgjMG3advpN3x6XF35xsgScnWm0KKTERG4CYZ8,2201
+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=Yg9ET6ZV5B9GW7u6zZA6GlB_71kmvxvYX2FWgQNzMvo,3182
 port_ocean/core/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/integrations/base.py,sha256=KHsRYFZ38ff3AkkqIQu45883ovgKOJn_fZfnTNy7HWY,2952
 port_ocean/core/integrations/mixins/__init__.py,sha256=FA1FEKMM6P-L2_m7Q4L20mFa4_RgZnwSRmTCreKcBVM,220
@@ -91,9 +93,9 @@ port_ocean/core/integrations/mixins/handler.py,sha256=mZ7-0UlG3LcrwJttFbMe-R4xcO
 port_ocean/core/integrations/mixins/sync.py,sha256=B9fEs8faaYLLikH9GBjE_E61vo0bQDjIGQsQ1SRXOlA,3931
 port_ocean/core/integrations/mixins/sync_raw.py,sha256=2vyHhGWyPchVfSUKRRfSJ2XsX55ygLWCFrKDaqkNd0o,18386
 port_ocean/core/integrations/mixins/utils.py,sha256=7y1rGETZIjOQadyIjFJXIHKkQFKx_SwiP-TrAIsyyLY,2303
-port_ocean/core/models.py,sha256=4bDvMeydlSpG0YSXjE1Bo2AcZC0aQ2zqFhpsOvZat_A,1190
+port_ocean/core/models.py,sha256=8yYyF4DQ4jMmQJPsmh5-XoF9gfHUTuBit6zuT-bxZ7Y,1228
 port_ocean/core/ocean_types.py,sha256=3_d8-n626f1kWLQ_Jxw194LEyrOVupz05qs_Y1pvB-A,990
-port_ocean/core/utils.py,sha256=WNtU7eqlFzq57PM8b2XVhVYcnjeByBovMuoeG502YGY,3588
+port_ocean/core/utils.py,sha256=GjAm66FiGR48-hT3Mo66G8B4_jYTqSEGh80zs39qYQs,3599
 port_ocean/exceptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/exceptions/api.py,sha256=TLmTMqn4uHGaHgZK8PMIJ0TVJlPB4iP7xl9rx7GtCyY,426
 port_ocean/exceptions/base.py,sha256=uY4DX7fIITDFfemCJDWpaZi3bD51lcANc5swpoNvMJA,46
@@ -110,7 +112,7 @@ port_ocean/log/handlers.py,sha256=k9G_Mb4ga2-Jke9irpdlYqj6EYiwv0gEsh4TgyqqOmI,28
 port_ocean/log/logger_setup.py,sha256=BaXt-mh9CVXhneh37H46d04lqOdIBixG1pFyGfotuZs,2328
 port_ocean/log/sensetive.py,sha256=wkyvkKMbyLTjZDSbvvLHL9bv4RvD0DPAyL3uWSttUOA,2916
 port_ocean/middlewares.py,sha256=6GrhldYAazxSwK2TbS-J28XdZ-9wO3PgCcyIMhnnJvI,2480
-port_ocean/ocean.py,sha256=jpWR9D9OVkEcKLky47pkrMBuuNtBZd5XKd8I9xr1gsE,4013
+port_ocean/ocean.py,sha256=0L8sj5TaIJSeYydO7jyANNinB1k0WwN-Q-ChWNnhJOs,4729
 port_ocean/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/run.py,sha256=rTxBlrQd4yyrtgErCFJCHCEHs7d1OXrRiJehUYmIbN0,2212
 port_ocean/sonar-project.properties,sha256=X_wLzDOkEVmpGLRMb2fg9Rb0DxWwUFSvESId8qpvrPI,73
@@ -120,13 +122,14 @@ port_ocean/utils/__init__.py,sha256=KMGnCPXZJbNwtgxtyMycapkDz8tpSyw23MSYT3iVeHs,
 port_ocean/utils/async_http.py,sha256=arnH458TExn2Dju_Sy6pHas_vF5RMWnOp-jBz5WAAcE,1226
 port_ocean/utils/async_iterators.py,sha256=buFBiPdsqkNMCk91h6ZG8hJa181j7RjgHajbfgeB8A8,1608
 port_ocean/utils/cache.py,sha256=3KItZDE2yVrbVDr-hoM8lNna8s2dlpxhP4ICdLjH4LQ,2231
-port_ocean/utils/misc.py,sha256=WZjrEDRfyeqbesVt_Nkp2yjazbKF-BOnxJMFAI721yQ,1965
+port_ocean/utils/misc.py,sha256=0q2cJ5psqxn_5u_56pT7vOVQ3shDM02iC1lzyWQ_zl0,2098
 port_ocean/utils/queue_utils.py,sha256=KWWl8YVnG-glcfIHhM6nefY-2sou_C6DVP1VynQwzB4,2762
 port_ocean/utils/repeat.py,sha256=0EFWM9d8lLXAhZmAyczY20LAnijw6UbIECf5lpGbOas,3231
 port_ocean/utils/signal.py,sha256=K-6kKFQTltcmKDhtyZAcn0IMa3sUpOHGOAUdWKgx0_E,1369
+port_ocean/utils/time.py,sha256=pufAOH5ZQI7gXvOvJoQXZXZJV-Dqktoj9Qp9eiRwmJ4,1939
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.9.14.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.9.14.dist-info/METADATA,sha256=iqvytPdN-Ao5wXE955d4-Lnnn_6HKxV8jQ357w_-hmY,6616
-port_ocean-0.9.14.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-port_ocean-0.9.14.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.9.14.dist-info/RECORD,,
+port_ocean-0.10.0.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.10.0.dist-info/METADATA,sha256=1T_SKzgGSYS3uiNJ6B29dszAsryEHYt0lm4r6TmyFng,6616
+port_ocean-0.10.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+port_ocean-0.10.0.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.10.0.dist-info/RECORD,,