port-ocean 0.9.14__tar.gz → 0.10.1__tar.gz

{port_ocean-0.9.14 → port_ocean-0.10.1}/PKG-INFO

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

{port_ocean-0.9.14 → port_ocean-0.10.1}/port_ocean/cli/commands/new.py

@@ -1,12 +1,39 @@
 # -*- coding: utf-8 -*-
 
 import click
+import json
 from cookiecutter.main import cookiecutter  # type: ignore
+import os
 
 from port_ocean.cli.commands.main import cli_start, print_logo, console
 from port_ocean.cli.utils import cli_root_path
 
 
+def add_vscode_configuration(result: str, name: str) -> None:
+    vscode_entry_root_path = "${workspaceFolder}/integrations/" + name
+    new_vscode_entry = {
+        "console": "integratedTerminal",
+        "cwd": vscode_entry_root_path,
+        "envFile": f"{vscode_entry_root_path}/.env",
+        "justMyCode": True,
+        "name": f"Run {name} integration",
+        "program": f"{vscode_entry_root_path}/debug.py",
+        "python": f"{vscode_entry_root_path}/.venv/bin/python",
+        "request": "launch",
+        "type": "debugpy",
+    }
+
+    vs_code_json_path = os.path.join(os.path.dirname(result), "../.vscode/launch.json")
+    if not os.path.exists(vs_code_json_path):
+        return
+    vs_code_json = json.load(open(vs_code_json_path, "r"))
+    vs_code_json["configurations"].append(new_vscode_entry)
+
+    with open(vs_code_json_path, "w") as vs_code_json_file:
+        json.dump(vs_code_json, vs_code_json_file, indent=2)
+        vs_code_json_file.write("\n")
+
+
 @cli_start.command()
 @click.argument("path", default=".", type=click.Path(exists=True))
 @click.option(
@@ -37,6 +64,9 @@ def new(path: str, is_private_integration: bool) -> None:
     )
     name = result.split("/")[-1]
 
+    if not is_private_integration:
+        add_vscode_configuration(result, name)
+
     console.print(
         "\n🌊 Ahoy, Captain! Your project is ready to set sail into the vast ocean of possibilities!",
         style="bold",
@@ -47,10 +77,14 @@ def new(path: str, is_private_integration: bool) -> None:
         f"▶️ [bold][blue]cd {path}/{name} && make install && . .venv/bin/activate[/blue][/bold]\n"
     )
     console.print(
-        "⚓️ Set sail with [blue]Ocean[/blue]: Run [bold][blue]ocean sail[/blue] <path_to_integration>[/bold] to run the project using Ocean.\n"
-        f"▶️ [bold][blue]ocean sail {path}/{name}[/blue][/bold] \n"
+        f"⚓️ Copy example env file: Run [bold][blue]cp {path}/{name}.env.example {path}/{name}/.env [/blue][/bold] and set your port credentials in the created file.\n"
     )
     console.print(
-        "⚓️ Smooth sailing with [blue]Make[/blue]: Alternatively, you can run [bold][blue]make run[/blue][/bold] to launch your project using Make. \n"
-        f"▶️ [bold][blue]make run {path}/{name}[/blue][/bold]"
+        "⚓️ Set sail with [blue]Ocean[/blue]: Run [bold][blue]ocean sail[/blue] <path_to_integration>[/bold] to run the project using Ocean.\n"
+        f"▶️ [bold][blue]ocean sail {path}/{name}[/blue][/bold] \n"
     )
+    if not is_private_integration:
+        console.print(
+            "⚓️ Smooth sailing with [blue]Make[/blue]: Alternatively, you can run [bold][blue]make run[/blue][/bold] to launch your project using Make. \n"
+            f"▶️ [bold][blue]make run {path}/{name}[/blue][/bold]"
+        )

port_ocean-0.10.1/port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.env.example

@@ -0,0 +1,2 @@
+OCEAN__PORT__CLIENT_ID="<port-client-id>"
+OCEAN__PORT__CLIENT_SECRET="<port-client-secret>"

port_ocean-0.10.1/port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.port/resources/blueprints.json

@@ -0,0 +1,41 @@
+[
+    {
+        "identifier": "{{ cookiecutter.integration_slug }}ExampleBlueprint",
+        "title": "{{ cookiecutter.integration_name }} Example",
+        "icon": "Blueprint",
+        "schema": {
+            "properties": {
+                "status": {
+                    "type": "string",
+                    "enum": [
+                        "VALID",
+                        "FAILED"
+                    ],
+                    "enumColors": {
+                        "VALID": "green",
+                        "FAILED": "red"
+                    },
+                    "title": "Status"
+                },
+                "text": {
+                    "type": "string",
+                    "title": "Text"
+                },
+                "component": {
+                    "type": "string",
+                    "title": "Component"
+                },
+                "service": {
+                    "type": "string",
+                    "title": "Service"
+                },
+                "score": {
+                    "type": "number",
+                    "title": "Score"
+                }
+            },
+            "required": []
+        },
+        "relations": {}
+    }
+]

port_ocean-0.10.1/port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.port/resources/port-app-config.yml

@@ -0,0 +1,16 @@
+resources:
+  - kind: {{ cookiecutter.integration_slug}}-example-kind
+    selector:
+      query: 'true'
+    port:
+      entity:
+        mappings:
+          identifier: .my_custom_id
+          title: '(.my_component + " @ " + .my_service)'
+          blueprint: '"{{ cookiecutter.integration_slug }}ExampleBlueprint"'
+          properties:
+            status: .my_enum
+            text: .my_custom_text
+            component: .my_component
+            service: .my_service
+            score: .my_special_score

port_ocean-0.10.1/port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.port/spec.yaml

@@ -0,0 +1,15 @@
+description: {{cookiecutter.integration_name}} integration for Port Ocean
+icon: Cookiecutter  # Should be one of the available icons in Port
+features:
+  - type: exporter
+    section: Under Development  # Should be one of the available sections in Port
+    resources:
+      - kind: {{ cookiecutter.integration_slug }}-example-kind
+      # - kind: <ResourceName2>
+configurations:
+  - name: my{{ cookiecutter.integration_slug}}Token
+    # required: true
+    type: string
+    sensitive: true
+  - name: someApplicationUrl
+    type: url

{port_ocean-0.9.14 → port_ocean-0.10.1}/port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/CHANGELOG.md

@@ -1,4 +1,4 @@
-# Changelog
+# Changelog - Ocean - {{ cookiecutter.integration_slug }}
 
 All notable changes to this project will be documented in this file.
 

port_ocean-0.10.1/port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/CONTRIBUTING.md

@@ -0,0 +1,7 @@
+# Contributing to Ocean - {{ cookiecutter.integration_slug }}
+
+## Running locally
+
+#### NOTE: Add your own instructions of how to run {{ cookiecutter.integration_slug }}
+
+This could be any gotcha's such as rate limiting, how to setup credentials and so forth

{port_ocean-0.9.14 → port_ocean-0.10.1}/port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/Makefile

@@ -55,8 +55,8 @@ lint:
 run:
 	$(ACTIVATE) && ocean sail
 
-test: lint
-	$(ACTIVATE) && poetry run pytest
+test:
+	$(ACTIVATE) && poetry run pytest -n auto
 
 clean:
 	@find . -name '.venv' -type d -exec rm -rf {} \;
@@ -71,4 +71,4 @@ clean:
 	rm -rf htmlcov
 	rm -rf .tox/
 	rm -rf docs/_build
-	rm -rf dist/
+	rm -rf dist/

{port_ocean-0.9.14 → port_ocean-0.10.1}/port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/changelog/.gitignore

@@ -1 +1,2 @@
+*
 !.gitignore

{port_ocean-0.9.14 → port_ocean-0.10.1}/port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/main.py

@@ -15,6 +15,21 @@ async def on_resync(kind: str) -> list[dict[Any, Any]]:
     #     return [{"some_project_key": "someProjectValue", ...}]
     # if kind == "issues":
     #     return [{"some_issue_key": "someIssueValue", ...}]
+
+    # Initial stub to show complete flow, replace this with your own logic
+    if kind == "{{ cookiecutter.integration_slug }}-example-kind":
+        return [
+            {
+                "my_custom_id": f"id_{x}",
+                "my_custom_text": f"very long text with {x} in it",
+                "my_special_score": x * 32 % 3,
+                "my_component": f"component-{x}",
+                "my_service": f"service-{x %2}",
+                "my_enum": "VALID" if x % 2 == 0 else "FAILED",
+            }
+            for x in range(25)
+        ]
+
     return []
 
 
@@ -38,4 +53,4 @@ async def on_resync(kind: str) -> list[dict[Any, Any]]:
 async def on_start() -> None:
     # Something to do when the integration starts
     # For example create a client to query 3rd party services - GitHub, Jira, etc...
-    print("Starting integration")
+    print("Starting {{ cookiecutter.integration_slug }} integration")

{port_ocean-0.9.14 → port_ocean-0.10.1}/port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/pyproject.toml

@@ -9,13 +9,17 @@ python = "^3.11"
 port_ocean = { version = "^{% version %}", extras = ["cli"] }
 
 [tool.poetry.group.dev.dependencies]
+# Uncomment this if you want to debug the ocean core together with your integration
+# port_ocean = { path = '../../', develop = true, extras = ['all'] }
 pytest = "^7.2"
+pytest-xdist = "^3.6.1"
+pre-commit = "^3.7.1"
+requests = "^2.32.3"
 black = "^23.3.0"
 mypy = "^1.3.0"
 ruff = "^0.0.278"
 pylint = "^2.17.4"
 towncrier = "^23.6.0"
-pytest-xdist = "^3.6.1"
 
 [tool.towncrier]
 directory = "changelog"
@@ -54,8 +58,8 @@ underlines = [""]
   showcontent = true
 
 [build-system]
-requires = ["poetry>=0.12"]
-build-backend = "poetry.masonry.api"
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"
 
 [tool.mypy]
 exclude = [

{port_ocean-0.9.14 → port_ocean-0.10.1}/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-0.9.14 → port_ocean-0.10.1}/port_ocean/clients/port/mixins/entities.py

@@ -58,7 +58,7 @@ class EntityClientMixin:
             )
         handle_status_code(response, should_raise)
         result = response.json()
-        result_entity = Entity.parse_obj(result)
+        result_entity = Entity.parse_obj(result["entity"])
         # Set the results of the search relation and identifier to the entity
         entity.identifier = result_entity.identifier or entity.identifier
         entity.relations = result_entity.relations or entity.relations

{port_ocean-0.9.14 → port_ocean-0.10.1}/port_ocean/config/settings.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal, Type
+from typing import Any, Literal, Type, cast
 
 from pydantic import Extra, AnyHttpUrl, parse_obj_as, parse_raw_as
 from pydantic.class_validators import root_validator, validator
@@ -55,9 +55,8 @@ class IntegrationSettings(BaseOceanModel, extra=Extra.allow):
             integ_type = get_integration_name()
 
         values["type"] = integ_type.lower() if integ_type else None
-        values["identifier"] = values.get(
-            "identifier", f"my-{integ_type}-integration".lower()
-        )
+        if not values.get("identifier"):
+            values["identifier"] = f"my-{integ_type}-integration".lower()
 
         return values
 
@@ -71,12 +70,14 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     client_timeout: int = 30
     send_raw_data_examples: bool = True
     port: PortSettings
-    event_listener: EventListenerSettingsType
+    event_listener: EventListenerSettingsType = Field(
+        default=cast(EventListenerSettingsType, {"type": "POLLING"})
+    )
     # If an identifier or type is not provided, it will be generated based on the integration name
     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 +101,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-0.10.1/port_ocean/core/event_listener/base.py

@@ -0,0 +1,84 @@
+from abc import abstractmethod
+from typing import TypedDict, Callable, Any, Awaitable
+
+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):
+    """
+    A dictionary containing event types and their corresponding event handlers.
+    """
+
+    on_resync: Callable[[dict[Any, Any]], Awaitable[None]]
+
+
+class BaseEventListener:
+    def __init__(
+        self,
+        events: EventListenerEvents,
+    ):
+        self.events = events
+
+    async def start(self) -> None:
+        signal_handler.register(self._stop)
+        await self._start()
+
+    @abstractmethod
+    async def _start(self) -> None:
+        pass
+
+    def _stop(self) -> None:
+        """
+        Can be used for event listeners that need cleanup before exiting.
+        """
+        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
+
+    def to_request(self) -> dict[str, Any]:
+        """
+        Converts the Settings object to a dictionary representation (request format).
+        """
+        return {"type": self.type}

{port_ocean-0.9.14 → port_ocean-0.10.1}/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-0.9.14 → port_ocean-0.10.1}/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-0.10.1/port_ocean/core/event_listener/once.py

@@ -0,0 +1,159 @@
+import datetime
+import signal
+from typing import Literal, Any
+
+from loguru import logger
+
+from port_ocean.core.event_listener.base import (
+    BaseEventListener,
+    EventListenerEvents,
+    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):
+    """
+    Once event listener configuration settings.
+    This class inherits from `EventListenerSettings`, which provides a foundation for creating event listener settings.
+    """
+
+    type: Literal["ONCE"]
+
+    def to_request(self) -> dict[str, Any]:
+        return {}
+
+
+class OnceEventListener(BaseEventListener):
+    """
+    Once event listener.
+
+    This event listener is used to trigger a resync immediately.
+
+    Parameters:
+        events (EventListenerEvents): A dictionary containing event types and their corresponding event handlers.
+        event_listener_config (OnceEventListenerSettings): The event listener configuration settings.
+    """
+
+    def __init__(
+        self,
+        events: EventListenerEvents,
+        event_listener_config: OnceEventListenerSettings,
+    ):
+        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:
+        """
+        Starts the resync process, and exits the application once finished.
+        """
+
+        # we use the `repeat_every` decorator to make sure the resync will be triggered, but won't stuck the application
+        # from finishing the startup process which is required to close the application gracefully
+        @repeat_every(seconds=0, max_repetitions=1)
+        async def resync_and_exit() -> None:
+            logger.info("Once event listener started")
+            try:
+                await self._resync({})
+            except Exception:
+                # we catch all exceptions here to make sure the application will exit gracefully
+                logger.exception("Error occurred while resyncing")
+            logger.info("Once event listener finished")
+            logger.info("Exiting application")
+            signal.raise_signal(signal.SIGINT)
+
+        await resync_and_exit()

{port_ocean-0.9.14 → port_ocean-0.10.1}/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-0.10.1/port_ocean/core/handlers/resync_state_updater/__init__.py

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