port-ocean 0.5.17__py3-none-any.whl → 0.5.21__py3-none-any.whl

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

@@ -1,4 +1,3 @@
-type: {{cookiecutter.integration_slug}}
 description: {{cookiecutter.integration_name}} integration for Port Ocean
 icon: Cookiecutter # Should be one of the available icons in Port
 features:

port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/pyproject.toml

@@ -1,5 +1,5 @@
 [tool.poetry]
-name = "{{cookiecutter.integration_name}}"
+name = "{{cookiecutter.integration_slug}}"
 version = "0.1.0"
 description = "{{cookiecutter.integration_short_description}}"
 authors = ["{{cookiecutter.full_name}} <{{cookiecutter.email}}>"]

port_ocean/clients/port/mixins/integrations.py

@@ -6,6 +6,7 @@ from starlette import status
 
 from port_ocean.clients.port.authentication import PortAuthentication
 from port_ocean.clients.port.utils import handle_status_code
+from port_ocean.log.sensetive import sensitive_log_filter
 
 if TYPE_CHECKING:
     from port_ocean.core.handlers.port_app_config.models import PortAppConfig
@@ -137,3 +138,18 @@ class IntegrationClientMixin:
         )
         handle_status_code(response)
         logger.debug("Logs successfully ingested")
+
+    async def ingest_integration_kind_examples(
+        self, kind: str, data: list[dict[str, Any]], should_log: bool = True
+    ):
+        logger.debug(f"Ingesting examples for kind: {kind}")
+        headers = await self.auth.headers()
+        response = await self.client.post(
+            f"{self.auth.api_url}/integration/{self.integration_identifier}/kinds/{kind}/examples",
+            headers=headers,
+            json={
+                "examples": sensitive_log_filter.mask_object(data, full_hide=True),
+            },
+        )
+        handle_status_code(response, should_log=should_log)
+        logger.debug(f"Examples for kind {kind} successfully ingested")

port_ocean/config/base.py

@@ -16,16 +16,15 @@ PROVIDER_CONFIG_PATTERN = r"^[a-zA-Z0-9]+ .*$"
 
 def read_yaml_config_settings_source(
     settings: "BaseOceanSettings", base_path: str
-) -> str:
+) -> dict[str, Any]:
     yaml_file = getattr(settings.__config__, "yaml_file", "")
 
     assert yaml_file, "Settings.yaml_file not properly configured"
     path = Path(base_path, yaml_file)
 
     if not path.exists():
-        raise FileNotFoundError(f"Could not open yaml settings file at: {path}")
-
-    return path.read_text("utf-8")
+        return {}
+    return yaml.safe_load(path.read_text("utf-8"))
 
 
 def parse_config_provider(value: str) -> tuple[str, str]:
@@ -122,8 +121,7 @@ def decamelize_config(
 def load_providers(
     settings: "BaseOceanSettings", existing_values: dict[str, Any], base_path: str
 ) -> dict[str, Any]:
-    yaml_content = read_yaml_config_settings_source(settings, base_path)
-    data = yaml.safe_load(yaml_content)
+    data = read_yaml_config_settings_source(settings, base_path)
     snake_case_config = decamelize_config(settings, data)
     return parse_providers(settings, snake_case_config, existing_values)
 

port_ocean/config/settings.py

@@ -1,12 +1,14 @@
 from typing import Any, Literal
 
-from pydantic import Extra, AnyHttpUrl, parse_obj_as, validator
+from pydantic import Extra, AnyHttpUrl, parse_obj_as
+from pydantic.class_validators import root_validator
 from pydantic.env_settings import InitSettingsSource, EnvSettingsSource, BaseSettings
 from pydantic.fields import Field
 from pydantic.main import BaseModel
 
 from port_ocean.config.base import BaseOceanSettings, BaseOceanModel
 from port_ocean.core.event_listener import EventListenerSettingsType
+from port_ocean.utils.misc import get_integration_name
 
 LogLevelType = Literal["ERROR", "WARNING", "INFO", "DEBUG", "CRITICAL"]
 
@@ -36,22 +38,34 @@ class PortSettings(BaseOceanModel, extra=Extra.allow):
     client_id: str = Field(..., sensitive=True)
     client_secret: str = Field(..., sensitive=True)
     base_url: AnyHttpUrl = parse_obj_as(AnyHttpUrl, "https://api.getport.io")
+    port_app_config_cache_ttl: int = 60
 
 
 class IntegrationSettings(BaseOceanModel, extra=Extra.allow):
-    identifier: str
-    type: str
+    identifier: str = Field(..., min_length=1)
+    type: str = Field(..., min_length=1)
     config: dict[str, Any] | BaseModel
 
-    @validator("identifier", "type")
-    def validate_lower(cls, v: str) -> str:
-        return v.lower()
+    @root_validator(pre=True)
+    def a(cls, values: dict[str, Any]) -> dict[str, Any]:
+        integ_type = values.get("type")
+
+        if not integ_type:
+            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()
+        )
+
+        return values
 
 
 class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     initialize_port_resources: bool = True
     scheduled_resync_interval: int | None = None
     client_timeout: int = 30
+    send_raw_data_examples: bool = True
     port: PortSettings
     event_listener: EventListenerSettingsType
     integration: IntegrationSettings

port_ocean/core/event_listener/base.py

@@ -1,5 +1,4 @@
 from abc import abstractmethod
-from asyncio import Task
 from typing import TypedDict, Callable, Any, Awaitable
 
 from pydantic import Extra
@@ -22,7 +21,6 @@ class BaseEventListener:
         events: EventListenerEvents,
     ):
         self.events = events
-        self._tasks_to_close: list[Task[Any]] = []
 
     async def start(self) -> None:
         signal_handler.register(self._stop)
@@ -32,11 +30,6 @@ class BaseEventListener:
     async def _start(self) -> None:
         pass
 
-    def stop(self) -> None:
-        self._stop()
-        for task in self._tasks_to_close:
-            task.cancel()
-
     def _stop(self) -> None:
         """
         Can be used for event listeners that need cleanup before exiting.

port_ocean/core/event_listener/polling.py

@@ -10,6 +10,7 @@ from port_ocean.core.event_listener.base import (
     EventListenerSettings,
 )
 from port_ocean.utils.repeat import repeat_every
+from port_ocean.utils.signal import signal_handler
 
 
 class PollingEventListenerSettings(EventListenerSettings):
@@ -79,7 +80,7 @@ class PollingEventListener(BaseEventListener):
                 running_task: Task[Any] = get_event_loop().create_task(
                     self.events["on_resync"]({})  # type: ignore
                 )
-                self._tasks_to_close.append(running_task)
+                signal_handler.register(running_task.cancel)
 
                 await running_task
 

port_ocean/core/handlers/entity_processor/base.py

@@ -40,6 +40,7 @@ class BaseEntityProcessor(BaseHandler):
         mapping: ResourceConfig,
         raw_data: list[RAW_ITEM],
         parse_all: bool = False,
+        send_raw_data_examples_amount: int = 0,
     ) -> EntitySelectorDiff:
         pass
 
@@ -48,6 +49,7 @@ class BaseEntityProcessor(BaseHandler):
         mapping: ResourceConfig,
         raw_data: list[RAW_ITEM],
         parse_all: bool = False,
+        send_raw_data_examples_amount: int = 0,
     ) -> EntitySelectorDiff:
         """Public method to parse raw entity data and map it to an EntityDiff.
 
@@ -55,9 +57,12 @@ class BaseEntityProcessor(BaseHandler):
             mapping (ResourceConfig): The configuration for entity mapping.
             raw_data (list[RawEntity]): The raw data to be parsed.
             parse_all (bool): Whether to parse all data or just data that passed the selector.
+            send_raw_data_examples_amount (bool): Whether to send example data to the integration service.
 
         Returns:
             EntityDiff: The parsed entity differences.
         """
         with logger.contextualize(kind=mapping.kind):
-            return await self._parse_items(mapping, raw_data, parse_all)
+            return await self._parse_items(
+                mapping, raw_data, parse_all, send_raw_data_examples_amount
+            )

port_ocean/core/handlers/entity_processor/jq_entity_processor.py

@@ -1,11 +1,13 @@
 import asyncio
 import functools
+from dataclasses import dataclass, field
 from functools import lru_cache
-from typing import Any
-from loguru import logger
+from typing import Any, Optional
 
 import pyjq as jq  # type: ignore
+from loguru import logger
 
+from port_ocean.context.ocean import ocean
 from port_ocean.core.handlers.entity_processor.base import BaseEntityProcessor
 from port_ocean.core.handlers.port_app_config.models import ResourceConfig
 from port_ocean.core.models import Entity
@@ -14,6 +16,19 @@ from port_ocean.core.ocean_types import (
     EntitySelectorDiff,
 )
 from port_ocean.exceptions.core import EntityProcessorException
+from port_ocean.utils.queue_utils import process_in_queue
+
+
+@dataclass
+class MappedEntity:
+    """Represents the entity after applying the mapping
+
+    This class holds the mapping entity along with the selector boolean value and optionally the raw data.
+    """
+
+    entity: dict[str, Any] = field(default_factory=dict)
+    did_entity_pass_selector: bool = False
+    raw_data: Optional[dict[str, Any]] = None
 
 
 class JQEntityProcessor(BaseEntityProcessor):
@@ -77,13 +92,17 @@ class JQEntityProcessor(BaseEntityProcessor):
         raw_entity_mappings: dict[str, Any],
         selector_query: str,
         parse_all: bool = False,
-    ) -> tuple[dict[str, Any], bool]:
+    ) -> MappedEntity:
         should_run = await self._search_as_bool(data, selector_query)
         if parse_all or should_run:
             mapped_entity = await self._search_as_object(data, raw_entity_mappings)
-            return mapped_entity, should_run
+            return MappedEntity(
+                mapped_entity,
+                did_entity_pass_selector=should_run,
+                raw_data=data if should_run else None,
+            )
 
-        return {}, False
+        return MappedEntity()
 
     async def _calculate_entity(
         self,
@@ -92,7 +111,7 @@ class JQEntityProcessor(BaseEntityProcessor):
         items_to_parse: str | None,
         selector_query: str,
         parse_all: bool = False,
-    ) -> list[tuple[dict[str, Any], bool]]:
+    ) -> list[MappedEntity]:
         if items_to_parse:
             items = await self._search(data, items_to_parse)
             if isinstance(items, list):
@@ -117,40 +136,58 @@ class JQEntityProcessor(BaseEntityProcessor):
                     data, raw_entity_mappings, selector_query, parse_all
                 )
             ]
-        return [({}, False)]
+        return [MappedEntity()]
+
+    @staticmethod
+    async def _send_examples(data: list[dict[str, Any]], kind: str) -> None:
+        try:
+            if data:
+                await ocean.port_client.ingest_integration_kind_examples(
+                    kind, data, should_log=False
+                )
+        except Exception as ex:
+            logger.warning(
+                f"Failed to send raw data example {ex}",
+                exc_info=True,
+            )
 
     async def _parse_items(
         self,
         mapping: ResourceConfig,
         raw_results: list[RAW_ITEM],
         parse_all: bool = False,
+        send_raw_data_examples_amount: int = 0,
     ) -> EntitySelectorDiff:
         raw_entity_mappings: dict[str, Any] = mapping.port.entity.mappings.dict(
             exclude_unset=True
         )
-        calculate_entities_tasks = [
-            asyncio.create_task(
-                self._calculate_entity(
-                    data,
-                    raw_entity_mappings,
-                    mapping.port.items_to_parse,
-                    mapping.selector.query,
-                    parse_all,
-                )
-            )
-            for data in raw_results
-        ]
-        calculate_entities_results = await asyncio.gather(*calculate_entities_tasks)
+
+        calculated_entities_results = await process_in_queue(
+            raw_results,
+            self._calculate_entity,
+            raw_entity_mappings,
+            mapping.port.items_to_parse,
+            mapping.selector.query,
+            parse_all,
+        )
 
         passed_entities = []
         failed_entities = []
-        for entities_results in calculate_entities_results:
-            for entity, did_entity_pass_selector in entities_results:
-                if entity.get("identifier") and entity.get("blueprint"):
-                    parsed_entity = Entity.parse_obj(entity)
-                    if did_entity_pass_selector:
+        examples_to_send: list[dict[str, Any]] = []
+        for entities_results in calculated_entities_results:
+            for result in entities_results:
+                if result.entity.get("identifier") and result.entity.get("blueprint"):
+                    parsed_entity = Entity.parse_obj(result.entity)
+                    if result.did_entity_pass_selector:
                         passed_entities.append(parsed_entity)
+                        if (
+                            len(examples_to_send) < send_raw_data_examples_amount
+                            and result.raw_data is not None
+                        ):
+                            examples_to_send.append(result.raw_data)
                     else:
                         failed_entities.append(parsed_entity)
 
+        await self._send_examples(examples_to_send, mapping.kind)
+
         return EntitySelectorDiff(passed=passed_entities, failed=failed_entities)

port_ocean/core/handlers/port_app_config/base.py

@@ -5,8 +5,36 @@ from loguru import logger
 from pydantic import ValidationError
 
 from port_ocean.context.event import event
+from port_ocean.context.ocean import PortOceanContext
 from port_ocean.core.handlers.base import BaseHandler
 from port_ocean.core.handlers.port_app_config.models import PortAppConfig
+from port_ocean.utils.misc import get_time
+
+
+class PortAppConfigCache:
+    _port_app_config: PortAppConfig | None
+    _retrieval_time: float
+
+    def __init__(self, cache_ttl: int):
+        self._cache_ttl = cache_ttl
+
+    @property
+    def port_app_config(self) -> PortAppConfig:
+        if self._port_app_config is None:
+            raise ValueError("Port app config is not set")
+        return self._port_app_config
+
+    @port_app_config.setter
+    def port_app_config(self, value: PortAppConfig) -> None:
+        self._retrieval_time = get_time()
+        self._port_app_config = value
+
+    @property
+    def is_cache_invalid(self) -> bool:
+        return (
+            not self._port_app_config
+            or self._retrieval_time + self._cache_ttl < get_time()
+        )
 
 
 class BasePortAppConfig(BaseHandler):
@@ -21,24 +49,34 @@ class BasePortAppConfig(BaseHandler):
 
     CONFIG_CLASS: Type[PortAppConfig] = PortAppConfig
 
+    def __init__(self, context: PortOceanContext):
+        super().__init__(context)
+        self._app_config_cache = PortAppConfigCache(
+            self.context.config.port.port_app_config_cache_ttl
+        )
+
     @abstractmethod
     async def _get_port_app_config(self) -> dict[str, Any]:
         pass
 
-    async def get_port_app_config(self) -> PortAppConfig:
-        """Retrieve and parse the port application configuration.
+    async def get_port_app_config(self, use_cache: bool = True) -> PortAppConfig:
+        """
+        Retrieve and parse the port application configuration.
 
-        Returns:
-            PortAppConfig: The parsed port application configuration.
+        :param use_cache: Determines whether to use the cached port-app-config if it exists, or to fetch it regardless
+        :return: The parsed port application configuration.
         """
-        raw_config = await self._get_port_app_config()
-        try:
-            config = self.CONFIG_CLASS.parse_obj(raw_config)
-        except ValidationError:
-            logger.error(
-                "Invalid port app config found. Please check that the integration has been configured correctly."
-            )
-            raise
-
-        event.port_app_config = config
-        return config
+        if not use_cache or self._app_config_cache.is_cache_invalid:
+            raw_config = await self._get_port_app_config()
+            try:
+                self._app_config_cache.port_app_config = self.CONFIG_CLASS.parse_obj(
+                    raw_config
+                )
+            except ValidationError:
+                logger.error(
+                    "Invalid port app config found. Please check that the integration has been configured correctly."
+                )
+                raise
+
+        event.port_app_config = self._app_config_cache.port_app_config
+        return self._app_config_cache.port_app_config

port_ocean/core/integrations/mixins/sync_raw.py

@@ -30,6 +30,9 @@ from port_ocean.core.utils import zip_and_sum
 from port_ocean.exceptions.core import OceanAbortException
 
 
+SEND_RAW_DATA_EXAMPLES_AMOUNT = 5
+
+
 class SyncRawMixin(HandlerMixin, EventsMixin):
     """Mixin class for synchronization of raw constructed entities.
 
@@ -124,10 +127,13 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         self,
         raw_diff: list[tuple[ResourceConfig, list[RAW_ITEM]]],
         parse_all: bool = False,
+        send_raw_data_examples_amount: int = 0,
     ) -> list[EntitySelectorDiff]:
         return await asyncio.gather(
             *(
-                self.entity_processor.parse_items(mapping, results, parse_all)
+                self.entity_processor.parse_items(
+                    mapping, results, parse_all, send_raw_data_examples_amount
+                )
                 for mapping, results in raw_diff
             )
         )
@@ -138,8 +144,11 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         results: list[dict[Any, Any]],
         user_agent_type: UserAgentType,
         parse_all: bool = False,
+        send_raw_data_examples_amount: int = 0,
     ) -> EntitySelectorDiff:
-        objects_diff = await self._calculate_raw([(resource, results)], parse_all)
+        objects_diff = await self._calculate_raw(
+            [(resource, results)], parse_all, send_raw_data_examples_amount
+        )
         await self.entities_state_applier.upsert(
             objects_diff[0].passed, user_agent_type
         )
@@ -171,19 +180,32 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             else:
                 async_generators.append(result)
 
+        send_raw_data_examples_amount = (
+            SEND_RAW_DATA_EXAMPLES_AMOUNT if ocean.config.send_raw_data_examples else 0
+        )
         entities = (
             await self._register_resource_raw(
-                resource_config, raw_results, user_agent_type
+                resource_config,
+                raw_results,
+                user_agent_type,
+                send_raw_data_examples_amount=send_raw_data_examples_amount,
             )
         ).passed
 
         for generator in async_generators:
             try:
                 async for items in generator:
+                    if send_raw_data_examples_amount > 0:
+                        send_raw_data_examples_amount = max(
+                            0, send_raw_data_examples_amount - len(entities)
+                        )
                     entities.extend(
                         (
                             await self._register_resource_raw(
-                                resource_config, items, user_agent_type
+                                resource_config,
+                                items,
+                                user_agent_type,
+                                send_raw_data_examples_amount=send_raw_data_examples_amount,
                             )
                         ).passed
                     )
@@ -362,7 +384,11 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             EventType.RESYNC,
             trigger_type=trigger_type,
         ):
-            app_config = await self.port_app_config_handler.get_port_app_config()
+            # If a resync is triggered due to a mappings change, we want to make sure that we have the updated version
+            # rather than the old cache
+            app_config = await self.port_app_config_handler.get_port_app_config(
+                use_cache=False
+            )
 
             creation_results: list[tuple[list[Entity], list[Exception]]] = []
 

port_ocean/core/utils.py

@@ -28,38 +28,34 @@ def is_same_entity(first_entity: Entity, second_entity: Entity) -> bool:
     )
 
 
-def get_unique(array: list[Entity]) -> list[Entity]:
-    result: list[Entity] = []
-    for item in array:
-        if all(not is_same_entity(item, seen_item) for seen_item in result):
-            result.append(item)
-    return result
-
-
 def get_port_diff(
     before: Iterable[Entity],
     after: Iterable[Entity],
 ) -> EntityPortDiff:
-    return EntityPortDiff(
-        deleted=get_unique(
-            [
-                item
-                for item in before
-                if not any(is_same_entity(item, item_after) for item_after in after)
-            ],
-        ),
-        created=get_unique(
-            [
-                item
-                for item in after
-                if not any(is_same_entity(item, item_before) for item_before in before)
-            ],
-        ),
-        modified=get_unique(
-            [
-                item
-                for item in after
-                if any(is_same_entity(item, item_before) for item_before in before)
-            ],
-        ),
-    )
+    before_dict = {}
+    after_dict = {}
+    created = []
+    modified = []
+    deleted = []
+
+    # Create dictionaries for before and after lists
+    for entity in before:
+        key = (entity.identifier, entity.blueprint)
+        before_dict[key] = entity
+
+    for entity in after:
+        key = (entity.identifier, entity.blueprint)
+        after_dict[key] = entity
+
+    # Find created, modified, and deleted objects
+    for key, obj in after_dict.items():
+        if key not in before_dict:
+            created.append(obj)
+        else:
+            modified.append(obj)
+
+    for key, obj in before_dict.items():
+        if key not in after_dict:
+            deleted.append(obj)
+
+    return EntityPortDiff(created=created, modified=modified, deleted=deleted)

port_ocean/log/sensetive.py

@@ -1,5 +1,5 @@
 import re
-from typing import Callable, TYPE_CHECKING
+from typing import Any, Callable, TYPE_CHECKING
 
 if TYPE_CHECKING:
     from loguru import Record
@@ -35,16 +35,31 @@ class SensitiveLogFilter:
             [re.compile(re.escape(token.strip())) for token in tokens if token.strip()]
         )
 
+    def mask_string(self, string: str, full_hide: bool = False) -> str:
+        masked_string = string
+        for pattern in self.compiled_patterns:
+            replace: Callable[[re.Match[str]], str] | str = (
+                "[REDACTED]"
+                if full_hide
+                else lambda match: match.group()[:6] + "[REDACTED]"
+            )
+            masked_string = pattern.sub(replace, masked_string)
+        return masked_string
+
+    def mask_object(self, obj: Any, full_hide: bool = False) -> Any:
+        if isinstance(obj, str):
+            return self.mask_string(obj, full_hide)
+        if isinstance(obj, list):
+            return [self.mask_object(o, full_hide) for o in obj]
+        if isinstance(obj, dict):
+            for k, v in obj.items():
+                obj[k] = self.mask_object(v, full_hide)
+
+        return obj
+
     def create_filter(self, full_hide: bool = False) -> Callable[["Record"], bool]:
         def _filter(record: "Record") -> bool:
-            for pattern in self.compiled_patterns:
-                replace: Callable[[re.Match[str]], str] | str = (
-                    "[REDACTED]"
-                    if full_hide
-                    else lambda match: match.group()[:6] + "[REDACTED]"
-                )
-                record["message"] = pattern.sub(replace, record["message"])
-
+            record["message"] = self.mask_string(record["message"], full_hide)
             return True
 
         return _filter

port_ocean/ocean.py

@@ -1,7 +1,8 @@
 import asyncio
 import sys
 import threading
-from typing import Callable, Any, Dict
+from contextlib import asynccontextmanager
+from typing import Callable, Any, Dict, AsyncIterator
 
 from fastapi import FastAPI, APIRouter
 from loguru import logger
@@ -21,7 +22,7 @@ from port_ocean.core.integrations.base import BaseIntegration
 from port_ocean.log.sensetive import sensitive_log_filter
 from port_ocean.middlewares import request_handler
 from port_ocean.utils.repeat import repeat_every
-from port_ocean.utils.signal import init_signal_handler
+from port_ocean.utils.signal import signal_handler, init_signal_handler
 from port_ocean.version import __integration_version__
 
 
@@ -93,14 +94,17 @@ class Ocean:
     async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
         self.fast_api_app.include_router(self.integration_router, prefix="/integration")
 
-        @self.fast_api_app.on_event("startup")
-        async def startup() -> None:
-            init_signal_handler()
+        @asynccontextmanager
+        async def lifecycle(_: FastAPI) -> AsyncIterator[None]:
             try:
+                init_signal_handler()
                 await self.integration.start()
                 await self._setup_scheduled_resync()
+                yield None
+                signal_handler.exit()
             except Exception:
-                logger.exception("Failed to start integration")
+                logger.exception("Integration had a fatal error. Shutting down.")
                 sys.exit("Server stopped")
 
+        self.fast_api_app.router.lifespan_context = lifecycle
         await self.fast_api_app(scope, receive, send)

port_ocean/utils/misc.py

@@ -29,13 +29,25 @@ def get_function_location(func: Callable[..., Any]) -> str:
     return f"{file_path}:{line_number}"
 
 
-def get_integration_version() -> str:
+def get_pyproject_data() -> dict[str, Any] | None:
     try:
         with open("./pyproject.toml", "rb") as toml_file:
             pyproject_data = tomli.load(toml_file)
-            return pyproject_data["tool"]["poetry"]["version"]
+            return pyproject_data["tool"]["poetry"]
     except (FileNotFoundError, KeyError):
-        return ""
+        return None
+
+
+def get_integration_version() -> str:
+    if data := get_pyproject_data():
+        return data["version"]
+    return ""
+
+
+def get_integration_name() -> str:
+    if data := get_pyproject_data():
+        return data["name"]
+    return ""
 
 
 def get_spec_file(path: Path = Path(".")) -> dict[str, Any] | None:

port_ocean/utils/queue_utils.py

@@ -0,0 +1,81 @@
+import asyncio
+from asyncio import Queue, Task
+from typing import Any, TypeVar, Callable, Coroutine
+
+from loguru import logger
+
+T = TypeVar("T")
+
+
+async def _start_processor_worker(
+    queue: Queue[Any | None],
+    func: Callable[..., Coroutine[Any, Any, T]],
+    results: list[T],
+) -> None:
+    while True:
+        raw_params = await queue.get()
+        try:
+            if raw_params is None:
+                return
+            logger.debug(f"Processing {raw_params[0]}")
+            results.append(await func(*raw_params))
+        finally:
+            queue.task_done()
+
+
+async def process_in_queue(
+    objects_to_process: list[Any],
+    func: Callable[..., Coroutine[Any, Any, T]],
+    *args: Any,
+    concurrency: int = 50,
+) -> list[T]:
+    """
+    This function executes multiple asynchronous tasks in a bounded way
+    (e.g. having 200 tasks to execute, while running only 20 concurrently),
+    to prevent overload and memory issues when dealing with large sets of data and tasks.
+    read more -> https://stackoverflow.com/questions/38831322/making-1-milion-requests-with-aiohttp-asyncio-literally
+
+    Usage:
+    ```python
+    async def incrementBy(num: int, increment_by: int) -> int:
+        await asyncio.sleep(3)
+        return num + increment_by
+
+    async def main():
+        raw_objects = [1, 2, 3, 4, 5]
+        processed_objects = await process_in_queue(
+            raw_objects,
+            incrementBy,
+            5
+        )
+    ```
+
+    :param objects_to_process: A list of the raw objects to process
+    :param func: An async function that turns raw object into result object
+    :param args: Static arguments to pass to the func when called
+    :param concurrency: An integer specifying the concurrent workers count
+    :return: A list of result objects
+    """
+    queue: Queue[Any | None] = Queue(maxsize=concurrency * 2)
+    tasks: list[Task[Any]] = []
+    processing_results: list[T] = []
+
+    for i in range(concurrency):
+        tasks.append(
+            asyncio.create_task(
+                _start_processor_worker(queue, func, processing_results)
+            )
+        )
+
+    for i in range(len(objects_to_process)):
+        await queue.put((objects_to_process[i], *args))
+
+    for i in range(concurrency):
+        # We put None value into the queue, so the workers will know that we
+        # are done sending more input and they can terminate
+        await queue.put(None)
+
+    await queue.join()
+    await asyncio.gather(*tasks)
+
+    return processing_results

port_ocean/utils/signal.py

@@ -1,4 +1,3 @@
-import signal
 from typing import Callable, Any
 
 from werkzeug.local import LocalProxy, LocalStack
@@ -13,10 +12,8 @@ from port_ocean.utils.misc import generate_uuid
 class SignalHandler:
     def __init__(self) -> None:
         self._handlers: dict[str, Callable[[], Any]] = {}
-        signal.signal(signal.SIGINT, lambda _, __: self._exit())
-        signal.signal(signal.SIGTERM, lambda _, __: self._exit())
 
-    def _exit(self) -> None:
+    def exit(self) -> None:
         """
         Handles the exit signal.
         """

{port_ocean-0.5.17.dist-info → port_ocean-0.5.21.dist-info}/METADATA

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

@@ -20,17 +20,16 @@ port_ocean/cli/cookiecutter/hooks/post_gen_project.py,sha256=4WpFM5O7FXuaqBMrhtn
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.dockerignore,sha256=9Mz_WI7XBpKzlJ7ILb4vlcuzYkh98Ql3bP_5GHN1sRY,1034
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.gitignore,sha256=32p1lDW_g5hyBz486GWfDeR9m7ikFlASVri5a8vmNoo,2698
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.port/resources/.gitignore,sha256=kCpRPdl3S_jqYYZaOrc0-xa6-l3KqVjNRXc6jCkd_-Q,12
-port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.port/spec.yaml,sha256=Yq06gYoC6jFWES5mxlvJGFTGXbfD7E9R8j_PDbVIM3M,497
+port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/.port/spec.yaml,sha256=jTYvu-Iayl-bxc917Y7ejcC9KyvH-LSq4-bdYZCYsuM,457
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/CHANGELOG.md,sha256=nzAmB0Bjnd2eZo79OjrlyVOdpTBHTmTxvO7c2C8Q-VQ,292
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/Dockerfile,sha256=Hh1dBnL959V2n28pmqFpXSrNvSMQjX6fDCUos8ITiu0,326
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/Makefile,sha256=kTa72qEp8pi-joOH6zl8oeIgjEHSCF628p2074yHHNA,1779
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/README.md,sha256=5VZmgDRW9gO4d8UuzkujslOIDfIDBiAGL2Hd74HK770,468
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/changelog/.gitignore,sha256=kCpRPdl3S_jqYYZaOrc0-xa6-l3KqVjNRXc6jCkd_-Q,12
-port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/config.yaml,sha256=zKaBQNCbWEE3MFxDHaMn9NIeBGVPiZUV6cBjH35f2kw,906
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/debug.py,sha256=_TRsA2s6GV2E3CTI8CHcsH-ZuH4_Eh5-juDXWaET0ho,65
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/main.py,sha256=KxxtBrRygYOP0bulXySVYwX0fm_mm3QHqeEqwDwgXgY,1669
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/poetry.toml,sha256=kENq8nNmFPIzw9vySheyG4xHxAPuBSpZO1CYGD6G2NE,46
-port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/pyproject.toml,sha256=r7xF1yf7gtKIXhm5WKvtbVht4JHHtLxM249BbS58J-o,1928
+port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/pyproject.toml,sha256=zmkwpiBDiDhMKp1egULLnx6ftVBcVYh4ztGohs53rWA,1928
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/sonar-project.properties,sha256=timmRpoSd50BdxLf45OcFUk2qs855z610kzz3yLAqJw,124
 port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/cli/utils.py,sha256=IUK2UbWqjci-lrcDdynZXqVP5B5TcjF0w5CpEVUks-k,54
@@ -41,15 +40,15 @@ port_ocean/clients/port/client.py,sha256=3GYCM0ZkX3pB6sNoOb-7_6dm0Jr5_vqhflD9ilt
 port_ocean/clients/port/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/clients/port/mixins/blueprints.py,sha256=BiqkhvDFdkySWgL1NHI-LAQ9ieZWazZAojPo9E8d7U4,4575
 port_ocean/clients/port/mixins/entities.py,sha256=Lg5Sa6jQuhDTQKLURVavqXlBQt4-XPUUigB9JqQ1X0k,7364
-port_ocean/clients/port/mixins/integrations.py,sha256=GJRweeibfKhukOkWB07pb09G6pp06FOiXPJU-pOV7M8,5155
+port_ocean/clients/port/mixins/integrations.py,sha256=EDjWnDS55rbGyZ0lctxdxHm-KaKVsGqZG_dEX9He5gg,5883
 port_ocean/clients/port/mixins/migrations.py,sha256=A6896oJF6WbFL2WroyTkMzr12yhVyWqGoq9dtLNSKBY,1457
 port_ocean/clients/port/retry_transport.py,sha256=PtIZOAZ6V-ncpVysRUsPOgt8Sf01QLnTKB5YeKBxkJk,1861
 port_ocean/clients/port/types.py,sha256=nvlgiAq4WH5_F7wQbz_GAWl-faob84LVgIjZ2Ww5mTk,451
 port_ocean/clients/port/utils.py,sha256=O9mBu6zp4TfpS4SQ3qCPpn9ZVyYF8GKnji4UnYhM3yg,2373
 port_ocean/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/config/base.py,sha256=8JoyjTPJS_BeYMnGnKN_q4SDaI-ydctuKl9ccK-Uq78,6474
+port_ocean/config/base.py,sha256=J_FUvlo0D4FbEbr4mgJsbGB5JjW9I7zMwfekj6T30KY,6389
 port_ocean/config/dynamic.py,sha256=qOFkRoJsn_BW7581omi_AoMxoHqasf_foxDQ_G11_SI,2030
-port_ocean/config/settings.py,sha256=5bQmOAIZ2IMDzUEsiVkfZokv9LxHLPOUVKA0TPoJh68,1769
+port_ocean/config/settings.py,sha256=ILWgh9358QI9TSbUtZo_reEtF33687_kW0nTniXEFJQ,2308
 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 +61,12 @@ port_ocean/core/defaults/clean.py,sha256=S3UAfca-oU89WJKIB4OgGjGjPr0vxBQ2aRZsLTZ
 port_ocean/core/defaults/common.py,sha256=QnLFTkT3yIWIRtLQb7fUvvfe5AfInYJy0q5LjlzHkOw,3553
 port_ocean/core/defaults/initialize.py,sha256=z7IdE_WN1_gF5_60OwSlid9-di7pYOJhzX8VdFjkXdc,7702
 port_ocean/core/event_listener/__init__.py,sha256=mzJ33wRq0kh60fpVdOHVmvMTUQIvz3vxmifyBgwDn0E,889
-port_ocean/core/event_listener/base.py,sha256=ntd41fGg_8X58hgnOrZaUVhDM1XbJSk5shf_MW3eAMQ,1327
+port_ocean/core/event_listener/base.py,sha256=4RujgPz4VfDFlviu4qLGJFnJougSCL-Ewf0rfTQfwgc,1133
 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=GFb89aqC2PrqDkah6gdxjsX1s4q3B87w0dVlZlUbScU,3485
+port_ocean/core/event_listener/polling.py,sha256=3UxjgQJly5y-hA8R798oFWb7bFsYMxSc6GRozA3biiM,3539
 port_ocean/core/handlers/__init__.py,sha256=R2HIRD8JTzupY4mXuXveMBQbuiPiiB3Oivmpc5C2jjI,610
 port_ocean/core/handlers/base.py,sha256=cTarblazu8yh8xz2FpB-dzDKuXxtoi143XJgPbV_DcM,157
 port_ocean/core/handlers/entities_state_applier/__init__.py,sha256=kgLZDCeCEzi4r-0nzW9k78haOZNf6PX7mJOUr34A4c8,173
@@ -77,11 +76,11 @@ port_ocean/core/handlers/entities_state_applier/port/applier.py,sha256=G6RyPgBAy
 port_ocean/core/handlers/entities_state_applier/port/get_related_entities.py,sha256=1zncwCbE-Gej0xaWKlzZgoXxOBe9bgs_YxlZ8QW3NdI,1751
 port_ocean/core/handlers/entities_state_applier/port/order_by_entities_dependencies.py,sha256=82BvU8t5w9uhsxX8hbnwuRPuWhW3cMeuT_5sVIkip1I,1550
 port_ocean/core/handlers/entity_processor/__init__.py,sha256=FvFCunFg44wNQoqlybem9MthOs7p1Wawac87uSXz9U8,156
-port_ocean/core/handlers/entity_processor/base.py,sha256=4JVCAAohEKtl8FdlnuyIxJ1afSXk3o2-e_m4LSy7vmw,1952
-port_ocean/core/handlers/entity_processor/jq_entity_processor.py,sha256=R5PwTcsJYRVU-lwoYZa1Af8kserp2BXIpyzVtRdEqA8,5617
+port_ocean/core/handlers/entity_processor/base.py,sha256=3e5QHlSjE7CCAv0WFSyQ7AhFEOS6-9eHj-ZYXGuvqFQ,2216
+port_ocean/core/handlers/entity_processor/jq_entity_processor.py,sha256=mF3ZyO1aSVxfefoeXSlTaIAFdoqITdsEuxlo2d1dUxM,6913
 port_ocean/core/handlers/port_app_config/__init__.py,sha256=8AAT5OthiVM7KCcM34iEgEeXtn2pRMrT4Dze5r1Ixbk,134
 port_ocean/core/handlers/port_app_config/api.py,sha256=6VbKPwFzsWG0IYsVD81hxSmfqtHUFqrfUuj1DBX5g4w,853
-port_ocean/core/handlers/port_app_config/base.py,sha256=nnMZ4jH6a-4Of9Cn-apMsU0CgNLD9avd5q0gRmc7nZ8,1495
+port_ocean/core/handlers/port_app_config/base.py,sha256=oufdNLzUmEgJY5PgIz75zDlowWrjA-y8WR4UnM58E58,2897
 port_ocean/core/handlers/port_app_config/models.py,sha256=WtF2uW4KPUPfDpy6E2tl9qXh5GUcDucVvKt0DCTYv6w,1985
 port_ocean/core/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/integrations/base.py,sha256=3jU0skK_gMLB8a_fN8whsRKva-Dz058TFoI0vXTbryU,3193
@@ -89,11 +88,11 @@ port_ocean/core/integrations/mixins/__init__.py,sha256=FA1FEKMM6P-L2_m7Q4L20mFa4
 port_ocean/core/integrations/mixins/events.py,sha256=Ddfx2L4FpghV38waF8OfVeOV0bHBxNIgjU-q5ffillI,2341
 port_ocean/core/integrations/mixins/handler.py,sha256=mZ7-0UlG3LcrwJttFbMe-R4xcOU2H_g33tZar7PwTv8,3771
 port_ocean/core/integrations/mixins/sync.py,sha256=TKqRytxXONVhuCo3CB3rDvWNbITnZz33TYTDs3SWWVk,3880
-port_ocean/core/integrations/mixins/sync_raw.py,sha256=kWZ44L2M2G6B0n3oOqF1Ko9Rct06CXnTnWY25Q2eh3c,15049
+port_ocean/core/integrations/mixins/sync_raw.py,sha256=DQ5pNqUedYXXykuMqecMhqi0GwMAvMWUZsTcjmkycxY,16137
 port_ocean/core/integrations/mixins/utils.py,sha256=7y1rGETZIjOQadyIjFJXIHKkQFKx_SwiP-TrAIsyyLY,2303
 port_ocean/core/models.py,sha256=bDO_I4Yd33TEZIh2QSV8UwXQIuwE7IgrINkYDHI0dkc,714
 port_ocean/core/ocean_types.py,sha256=ltnn22eRuDMFW02kIgmIAu6S06-i9jJV2NJ-MZcwwj0,879
-port_ocean/core/utils.py,sha256=B040Wokk28g9tQj_06qk_uvm85RIXc6XGXysZV6gtQw,1957
+port_ocean/core/utils.py,sha256=6rYtsb1bjW8owxWngGiV3awMLZkP3tXZdxXClmRD1SU,1824
 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
@@ -108,9 +107,9 @@ port_ocean/helpers/retry.py,sha256=hcfVmt2Fp53EQViYiOWA-FTWD80jvS-mWKhwMHiBM7Q,1
 port_ocean/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/log/handlers.py,sha256=k9G_Mb4ga2-Jke9irpdlYqj6EYiwv0gEsh4TgyqqOmI,2853
 port_ocean/log/logger_setup.py,sha256=NGU9EdRTPLloiHdgSw0JYaYGr9mx1hYJUEPFHP6BA14,2175
-port_ocean/log/sensetive.py,sha256=4aD7tdOwoDGi69ah1E4qLnpjE7G6r_UxJ1MwxYit02g,2335
+port_ocean/log/sensetive.py,sha256=wkyvkKMbyLTjZDSbvvLHL9bv4RvD0DPAyL3uWSttUOA,2916
 port_ocean/middlewares.py,sha256=6GrhldYAazxSwK2TbS-J28XdZ-9wO3PgCcyIMhnnJvI,2480
-port_ocean/ocean.py,sha256=6MAg7qEVRqpMrKaFiuOKFYc4IEGnSQQJQSigk5Mge8w,4072
+port_ocean/ocean.py,sha256=nRTTh6faPrt77ozvKBFk6eCNxwzKcTDzJ4KPgpO4VRk,4304
 port_ocean/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/run.py,sha256=vyShtqg_jEiE6M4SJpci6c4oRD9k2ztesAXEx_6Sc9M,1906
 port_ocean/sonar-project.properties,sha256=X_wLzDOkEVmpGLRMb2fg9Rb0DxWwUFSvESId8qpvrPI,73
@@ -118,12 +117,13 @@ 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=2XmO8W0SgPjV0rd9HZvrHhoMlHprIwmMFsINxlAmgyw,1723
+port_ocean/utils/misc.py,sha256=WZjrEDRfyeqbesVt_Nkp2yjazbKF-BOnxJMFAI721yQ,1965
+port_ocean/utils/queue_utils.py,sha256=Pzb6e8PcjylZpXcb9EEIK-QcTty_E2k1egMiJF5J_8Q,2500
 port_ocean/utils/repeat.py,sha256=0EFWM9d8lLXAhZmAyczY20LAnijw6UbIECf5lpGbOas,3231
-port_ocean/utils/signal.py,sha256=Fab0049Cjs69TPTQgvEvilaVZKACQr6tGkRdySjNCi8,1515
+port_ocean/utils/signal.py,sha256=K-6kKFQTltcmKDhtyZAcn0IMa3sUpOHGOAUdWKgx0_E,1369
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.5.17.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.5.17.dist-info/METADATA,sha256=uaVWJBt0vRCLiqO22dU72mqY-rnoBZgXRKJvmCCKFzE,6554
-port_ocean-0.5.17.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-port_ocean-0.5.17.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.5.17.dist-info/RECORD,,
+port_ocean-0.5.21.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.5.21.dist-info/METADATA,sha256=w90EuOVc4M2mYy6KoaeLE03v0AoH_0SOgwf8RKy_e30,6554
+port_ocean-0.5.21.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+port_ocean-0.5.21.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.5.21.dist-info/RECORD,,

port_ocean/cli/cookiecutter/{{cookiecutter.integration_slug}}/config.yaml

@@ -1,17 +0,0 @@
-{{ "# This is an example configuration file for the integration service." }}
-{{ "# Please copy this file to config.yaml file in the integration folder and edit it to your needs." }}
-
-port:
-  clientId: "{{ '{{' }} from env PORT_CLIENT_ID {{ '}}' }}" {{ "# Can be loaded via environment variable: PORT_CLIENT_ID" }}
-  clientSecret: "{{ '{{' }} from env PORT_CLIENT_SECRET {{ '}}' }}" {{ "# Can be loaded via environment variable: PORT_CLIENT_SECRET" }}
-{{ "# The event listener to use for the integration service." }}
-eventListener:
-  type: KAFKA
-integration:
-  {{ "# The identifier of this integration instance." }}
-  identifier: "{{ '{{' }} from env INTEGRATION_IDENTIFIER {{ '}}' }}"
-  {{ "# The type of the integration." }}
-  type: "My Integration type (Gitlab, Jira, etc.)"
-  config:
-    myGitToken: "{{ '{{' }} from env MY_GIT_TOKEN {{ '}}' }}"
-    someApplicationUrl: "https://I-Am-Not-A-Real-Url.com"