port-ocean 0.18.2__py3-none-any.whl → 0.18.4__py3-none-any.whl

integrations/_infra/Makefile

@@ -41,7 +41,7 @@ define deactivate_virtualenv
     fi
 endef
 
-.SILENT: install install/prod install/local-core lint lint/fix run test clean
+.SILENT: install install/prod install/local-core lint lint/fix run test clean seed
 
 install:
 	$(call deactivate_virtualenv) && \
@@ -85,3 +85,11 @@ clean:
 	rm -rf .tox/
 	rm -rf docs/_build
 	rm -rf dist/
+
+seed:
+	@if [ -f "tests/seed_data.py" ]; then \
+		$(ACTIVATE) && python tests/seed_data.py; \
+	else \
+		echo "No seeding script found. Create tests/seed_data.py for this integration if needed."; \
+		exit 0; \
+	fi

port_ocean/clients/port/client.py

@@ -5,6 +5,7 @@ from port_ocean.clients.port.mixins.blueprints import BlueprintClientMixin
 from port_ocean.clients.port.mixins.entities import EntityClientMixin
 from port_ocean.clients.port.mixins.integrations import IntegrationClientMixin
 from port_ocean.clients.port.mixins.migrations import MigrationClientMixin
+from port_ocean.clients.port.mixins.organization import OrganizationClientMixin
 from port_ocean.clients.port.types import (
     KafkaCreds,
 )
@@ -21,6 +22,7 @@ class PortClient(
     IntegrationClientMixin,
     BlueprintClientMixin,
     MigrationClientMixin,
+    OrganizationClientMixin,
 ):
     def __init__(
         self,
@@ -48,6 +50,7 @@ class PortClient(
         )
         BlueprintClientMixin.__init__(self, self.auth, self.client)
         MigrationClientMixin.__init__(self, self.auth, self.client)
+        OrganizationClientMixin.__init__(self, self.auth, self.client)
 
     async def get_kafka_creds(self) -> KafkaCreds:
         logger.info("Fetching organization kafka credentials")

port_ocean/clients/port/mixins/entities.py

@@ -22,7 +22,9 @@ class EntityClientMixin:
         # Semaphore is used to limit the number of concurrent requests to port, to avoid overloading it.
         # The number of concurrent requests is set to 90% of the max connections limit, to leave some room for other
         # requests that are not related to entities.
-        self.semaphore = asyncio.Semaphore(round(0.9 * PORT_HTTP_MAX_CONNECTIONS_LIMIT))
+        self.semaphore = asyncio.Semaphore(
+            round(0.5 * PORT_HTTP_MAX_CONNECTIONS_LIMIT)
+        )  # 50% of the max connections limit in order to avoid overloading port
 
     async def upsert_entity(
         self,

port_ocean/clients/port/mixins/integrations.py

@@ -1,16 +1,25 @@
-from typing import Any, TYPE_CHECKING, Optional, TypedDict
+import asyncio
+from typing import Any, Dict, TYPE_CHECKING, Optional, TypedDict
 from urllib.parse import quote_plus
 
 import httpx
 from loguru import logger
 from port_ocean.clients.port.authentication import PortAuthentication
 from port_ocean.clients.port.utils import handle_status_code
+from port_ocean.exceptions.port_defaults import DefaultsProvisionFailed
 from port_ocean.log.sensetive import sensitive_log_filter
 
 if TYPE_CHECKING:
     from port_ocean.core.handlers.port_app_config.models import PortAppConfig
 
 
+INTEGRATION_POLLING_INTERVAL_INITIAL_SECONDS = 3
+INTEGRATION_POLLING_INTERVAL_BACKOFF_FACTOR = 1.15
+INTEGRATION_POLLING_RETRY_LIMIT = 30
+CREATE_RESOURCES_PARAM_NAME = "integration_modes"
+CREATE_RESOURCES_PARAM_VALUE = ["create_resources"]
+
+
 class LogAttributes(TypedDict):
     ingestUrl: str
 
@@ -50,12 +59,41 @@ class IntegrationClientMixin:
             self._log_attributes = response["logAttributes"]
         return self._log_attributes
 
+    async def _poll_integration_until_default_provisioning_is_complete(
+        self,
+    ) -> Dict[str, Any]:
+        attempts = 0
+        current_interval_seconds = INTEGRATION_POLLING_INTERVAL_INITIAL_SECONDS
+
+        while attempts < INTEGRATION_POLLING_RETRY_LIMIT:
+            logger.info(
+                f"Fetching created integration and validating config, attempt {attempts+1}/{INTEGRATION_POLLING_RETRY_LIMIT}",
+                attempt=attempts,
+            )
+            response = await self._get_current_integration()
+            integration_json = response.json()
+            if integration_json.get("integration", {}).get("config", {}):
+                return integration_json
+
+            logger.info(
+                f"Integration config is still being provisioned, retrying in {current_interval_seconds} seconds"
+            )
+            await asyncio.sleep(current_interval_seconds)
+
+            attempts += 1
+            current_interval_seconds = int(
+                current_interval_seconds * INTEGRATION_POLLING_INTERVAL_BACKOFF_FACTOR
+            )
+
+        raise DefaultsProvisionFailed(INTEGRATION_POLLING_RETRY_LIMIT)
+
     async def create_integration(
         self,
         _type: str,
         changelog_destination: dict[str, Any],
         port_app_config: Optional["PortAppConfig"] = None,
-    ) -> dict:
+        create_port_resources_origin_in_port: Optional[bool] = False,
+    ) -> Dict[str, Any]:
         logger.info(f"Creating integration with id: {self.integration_identifier}")
         headers = await self.auth.headers()
         json = {
@@ -65,12 +103,26 @@ class IntegrationClientMixin:
             "changelogDestination": changelog_destination,
             "config": {},
         }
-        if port_app_config:
+
+        query_params = {}
+
+        if create_port_resources_origin_in_port:
+            query_params[CREATE_RESOURCES_PARAM_NAME] = CREATE_RESOURCES_PARAM_VALUE
+
+        if port_app_config and not create_port_resources_origin_in_port:
             json["config"] = port_app_config.to_request()
         response = await self.client.post(
-            f"{self.auth.api_url}/integration", headers=headers, json=json
+            f"{self.auth.api_url}/integration",
+            headers=headers,
+            json=json,
+            params=query_params,
         )
         handle_status_code(response)
+        if create_port_resources_origin_in_port:
+            result = (
+                await self._poll_integration_until_default_provisioning_is_complete()
+            )
+            return result["integration"]
         return response.json()["integration"]
 
     async def patch_integration(

port_ocean/clients/port/mixins/organization.py

@@ -0,0 +1,31 @@
+from typing import List
+import httpx
+from loguru import logger
+from port_ocean.clients.port.authentication import PortAuthentication
+from port_ocean.clients.port.utils import handle_status_code
+
+
+class OrganizationClientMixin:
+    def __init__(
+        self,
+        auth: PortAuthentication,
+        client: httpx.AsyncClient,
+    ):
+        self.auth = auth
+        self.client = client
+
+    async def _get_organization_feature_flags(self) -> httpx.Response:
+        logger.info("Fetching organization feature flags")
+
+        response = await self.client.get(
+            f"{self.auth.api_url}/organization",
+            headers=await self.auth.headers(),
+        )
+        return response
+
+    async def get_organization_feature_flags(
+        self, should_raise: bool = True, should_log: bool = True
+    ) -> List[str]:
+        response = await self._get_organization_feature_flags()
+        handle_status_code(response, should_raise, should_log)
+        return response.json().get("organization", {}).get("featureFlags", [])

port_ocean/config/settings.py

@@ -8,7 +8,7 @@ from pydantic.main import BaseModel
 
 from port_ocean.config.base import BaseOceanSettings, BaseOceanModel
 from port_ocean.core.event_listener import EventListenerSettingsType
-from port_ocean.core.models import Runtime
+from port_ocean.core.models import CreatePortResourcesOrigin, Runtime
 from port_ocean.utils.misc import get_integration_name, get_spec_file
 
 LogLevelType = Literal["ERROR", "WARNING", "INFO", "DEBUG", "CRITICAL"]
@@ -68,6 +68,8 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     initialize_port_resources: bool = True
     scheduled_resync_interval: int | None = None
     client_timeout: int = 60
+    # Determines if Port should generate resources such as blueprints and pages instead of ocean
+    create_port_resources_origin: CreatePortResourcesOrigin | None = None
     send_raw_data_examples: bool = True
     port: PortSettings
     event_listener: EventListenerSettingsType = Field(
@@ -101,6 +103,20 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
 
         return values
 
+    @validator("create_port_resources_origin")
+    def validate_create_port_resources_origin(
+        cls, create_port_resources_origin: CreatePortResourcesOrigin | None
+    ) -> CreatePortResourcesOrigin | None:
+        spec = get_spec_file()
+        if spec and spec.get("create_port_resources_origin", None):
+            spec_create_port_resources_origin = spec.get("create_port_resources_origin")
+            if spec_create_port_resources_origin in [
+                CreatePortResourcesOrigin.Port,
+                CreatePortResourcesOrigin.Ocean,
+            ]:
+                return CreatePortResourcesOrigin(spec_create_port_resources_origin)
+        return create_port_resources_origin
+
     @validator("runtime")
     def validate_runtime(cls, runtime: Runtime) -> Runtime:
         if runtime.is_saas_runtime:

port_ocean/core/defaults/initialize.py

@@ -13,12 +13,14 @@ from port_ocean.core.defaults.common import (
     get_port_integration_defaults,
 )
 from port_ocean.core.handlers.port_app_config.models import PortAppConfig
-from port_ocean.core.models import Blueprint
+from port_ocean.core.models import Blueprint, CreatePortResourcesOrigin
 from port_ocean.core.utils.utils import gather_and_split_errors_from_results
 from port_ocean.exceptions.port_defaults import (
     AbortDefaultCreationError,
 )
 
+ORG_USE_PROVISIONED_DEFAULTS_FEATURE_FLAG = "USE_PROVISIONED_DEFAULTS"
+
 
 def deconstruct_blueprints_to_creation_steps(
     raw_blueprints: list[dict[str, Any]],
@@ -54,8 +56,8 @@ def deconstruct_blueprints_to_creation_steps(
 
 async def _initialize_required_integration_settings(
     port_client: PortClient,
-    default_mapping: PortAppConfig,
     integration_config: IntegrationConfiguration,
+    default_mapping: PortAppConfig | None = None,
 ) -> None:
     try:
         logger.info("Initializing integration at port")
@@ -70,6 +72,8 @@ async def _initialize_required_integration_settings(
                 integration_config.integration.type,
                 integration_config.event_listener.get_changelog_destination_details(),
                 port_app_config=default_mapping,
+                create_port_resources_origin_in_port=integration_config.create_port_resources_origin
+                == CreatePortResourcesOrigin.Port,
             )
         elif not integration.get("config"):
             logger.info(
@@ -102,8 +106,10 @@ async def _initialize_required_integration_settings(
 
 async def _create_resources(
     port_client: PortClient,
-    defaults: Defaults,
+    defaults: Defaults | None = None,
 ) -> None:
+    if not defaults:
+        return
     creation_stage, *blueprint_patches = deconstruct_blueprints_to_creation_steps(
         defaults.blueprints
     )
@@ -199,22 +205,64 @@ async def _create_resources(
 async def _initialize_defaults(
     config_class: Type[PortAppConfig], integration_config: IntegrationConfiguration
 ) -> None:
+    if not integration_config.initialize_port_resources:
+        return
+
     port_client = ocean.port_client
     defaults = get_port_integration_defaults(
         config_class, integration_config.resources_path
     )
-    if not defaults:
+
+    if (
+        not integration_config.create_port_resources_origin
+        and integration_config.runtime.is_saas_runtime
+    ):
+        logger.info("Setting resources origin to be Port")
+        integration_config.create_port_resources_origin = CreatePortResourcesOrigin.Port
+
+    if (
+        integration_config.create_port_resources_origin
+        == CreatePortResourcesOrigin.Port
+    ):
+        logger.info(
+            "Resources origin is set to be Port, verifying integration is supported"
+        )
+        org_feature_flags = await port_client.get_organization_feature_flags()
+        if ORG_USE_PROVISIONED_DEFAULTS_FEATURE_FLAG not in org_feature_flags:
+            logger.info(
+                "Port origin for Integration is not supported, changing resources origin to use Ocean"
+            )
+            integration_config.create_port_resources_origin = (
+                CreatePortResourcesOrigin.Ocean
+            )
+
+    if (
+        integration_config.create_port_resources_origin
+        != CreatePortResourcesOrigin.Port
+        and not defaults
+    ):
         logger.warning("No defaults found. Skipping initialization...")
         return None
 
-    if defaults.port_app_config:
+    if (
+        (defaults and defaults.port_app_config)
+        or integration_config.create_port_resources_origin
+        == CreatePortResourcesOrigin.Port
+    ):
         await _initialize_required_integration_settings(
-            port_client, defaults.port_app_config, integration_config
+            port_client,
+            integration_config,
+            defaults.port_app_config if defaults else None,
         )
 
-    if not integration_config.initialize_port_resources:
+    if (
+        integration_config.create_port_resources_origin
+        == CreatePortResourcesOrigin.Port
+    ):
+        logger.info(
+            "Skipping creating defaults resources due to `create_port_resources_origin` being `Port`"
+        )
         return
-
     try:
         logger.info("Found default resources, starting creation process")
         await _create_resources(port_client, defaults)

port_ocean/core/integrations/mixins/sync_raw.py

@@ -220,33 +220,27 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         )
         modified_objects = []
 
-        if ocean.app.is_saas():
-            try:
-                changed_entities = await self._map_entities_compared_with_port(
-                    objects_diff[0].entity_selector_diff.passed,
-                    resource,
-                    user_agent_type
+        try:
+            changed_entities = await self._map_entities_compared_with_port(
+                objects_diff[0].entity_selector_diff.passed,
+                resource,
+                user_agent_type
+            )
+            if changed_entities:
+                logger.info("Upserting changed entities", changed_entities=len(changed_entities),
+                    total_entities=len(objects_diff[0].entity_selector_diff.passed))
+                await self.entities_state_applier.upsert(
+                    changed_entities, user_agent_type
                 )
-
-                if changed_entities:
-                    logger.info("Upserting changed entities", changed_entities=len(changed_entities),
-                        total_entities=len(objects_diff[0].entity_selector_diff.passed))
-                    await self.entities_state_applier.upsert(
-                        changed_entities, user_agent_type
-                    )
-                else:
-                    logger.info("Entities in batch didn't changed since last sync, skipping", total_entities=len(objects_diff[0].entity_selector_diff.passed))
-
-                modified_objects = [ocean.port_client._reduce_entity(entity) for entity in objects_diff[0].entity_selector_diff.passed]
-            except Exception as e:
-                logger.warning(f"Failed to resolve batch entities with Port, falling back to upserting all entities: {str(e)}")
-                modified_objects = await self.entities_state_applier.upsert(
-                    objects_diff[0].entity_selector_diff.passed, user_agent_type
-                    )
-        else:
+            else:
+                logger.info("Entities in batch didn't changed since last sync, skipping", total_entities=len(objects_diff[0].entity_selector_diff.passed))
+            modified_objects = [ocean.port_client._reduce_entity(entity) for entity in objects_diff[0].entity_selector_diff.passed]
+        except Exception as e:
+            logger.warning(f"Failed to resolve batch entities with Port, falling back to upserting all entities: {str(e)}")
             modified_objects = await self.entities_state_applier.upsert(
                 objects_diff[0].entity_selector_diff.passed, user_agent_type
-        )
+                )
+
         return CalculationResult(
             objects_diff[0].entity_selector_diff._replace(passed=modified_objects),
             errors=objects_diff[0].errors,

port_ocean/core/models.py

@@ -1,11 +1,16 @@
 from dataclasses import dataclass, field
-from enum import Enum
+from enum import Enum, StrEnum
 from typing import Any
 
 from pydantic import BaseModel
 from pydantic.fields import Field
 
 
+class CreatePortResourcesOrigin(StrEnum):
+    Ocean = "Ocean"
+    Port = "Port"
+
+
 class Runtime(Enum):
     Saas = "Saas"
     OnPrem = "OnPrem"

port_ocean/exceptions/port_defaults.py

@@ -14,3 +14,13 @@ class AbortDefaultCreationError(BaseOceanException):
 
 class UnsupportedDefaultFileType(BaseOceanException):
     pass
+
+
+class DefaultsProvisionFailed(BaseOceanException):
+    def __init__(
+        self,
+        retries: int,
+    ):
+        super().__init__(
+            f"Failed to retrieve integration config after {retries} attempts"
+        )

port_ocean/tests/clients/port/mixins/test_organization_mixin.py

@@ -0,0 +1,27 @@
+import pytest
+from unittest.mock import MagicMock, AsyncMock
+
+from port_ocean.clients.port.mixins.organization import OrganizationClientMixin
+
+
+@pytest.fixture
+async def mocked_org_mixin() -> OrganizationClientMixin:
+    auth = MagicMock()
+    auth.headers = AsyncMock()
+    auth.headers.return_value = {"auth": "enticated"}
+    client = MagicMock()
+    client.get = AsyncMock()
+    client.get.return_value = MagicMock()
+    client.get.return_value.json = MagicMock()
+    client.get.return_value.json.return_value = {
+        "organization": {"featureFlags": ["aa", "bb"]}
+    }
+    return OrganizationClientMixin(auth=auth, client=client)
+
+
+async def test_org_feature_flags_should_fetch_proper_json_path(
+    mocked_org_mixin: OrganizationClientMixin,
+) -> None:
+    result = await mocked_org_mixin.get_organization_feature_flags()
+
+    assert result == ["aa", "bb"]

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

@@ -433,93 +433,76 @@ async def test_sync_raw_mixin_dependency(
 @pytest.mark.asyncio
 async def test_register_raw(
     mock_sync_raw_mixin_with_jq_processor: SyncRawMixin,
-    mock_ocean: Ocean,
-    mock_context: PortOceanContext,
-    monkeypatch: pytest.MonkeyPatch,
+    mock_resource_config: ResourceConfig,
 ) -> None:
-    kind = "service"
-    user_agent_type = UserAgentType.exporter
-    raw_entity = [
-        {"id": "entity_1", "name": "entity_1", "web_url": "https://example.com"},
-    ]
-    expected_result = [
-        {
-            "identifier": "entity_1",
-            "blueprint": "service",
-            "name": "entity_1",
-            "properties": {"url": "https://example.com"},
-        },
-    ]
-
-    # Set is_saas to False
-    monkeypatch.setattr(mock_context.app, "is_saas", lambda: False)
-
-    async with event_context(EventType.HTTP_REQUEST, trigger_type="machine") as event:
-        # Use patch to mock the method instead of direct assignment
-        with patch.object(
-            mock_sync_raw_mixin_with_jq_processor.port_app_config_handler,
-            "get_port_app_config",
-            return_value=PortAppConfig(
-                enable_merge_entity=True,
-                delete_dependent_entities=True,
-                create_missing_related_entities=False,
-                resources=[
-                    ResourceConfig(
-                        kind=kind,
-                        selector=Selector(query="true"),
-                        port=PortResourceConfig(
-                            entity=MappingsConfig(
-                                mappings=EntityMapping(
-                                    identifier=".id | tostring",
-                                    title=".name",
-                                    blueprint='"service"',
-                                    properties={"url": ".web_url"},
-                                    relations={},
-                                )
-                            )
-                        ),
-                    )
-                ],
-            ),
-        ):
-            # Ensure the event.port_app_config is set correctly
-            event.port_app_config = await mock_sync_raw_mixin_with_jq_processor.port_app_config_handler.get_port_app_config(
-                use_cache=False
-            )
-
-            def upsert_side_effect(
-                entities: list[Entity], user_agent_type: UserAgentType
-            ) -> list[Entity]:
-                # Simulate returning the passed entities
-                return entities
+    # Mock the integration settings with skip_check_diff
+    with patch.object(ocean.config.integration, "skip_check_diff", False):
+        kind = "service"
+        user_agent_type = UserAgentType.exporter
+        raw_entity = [
+            {"id": "entity_1", "name": "entity_1", "web_url": "https://example.com"},
+        ]
+        expected_result = [
+            {
+                "identifier": "entity_1",
+                "blueprint": "service",
+                "name": "entity_1",
+                "properties": {},
+            },
+        ]
 
-            # Patch the upsert method with the side effect
+        async with event_context(
+            EventType.HTTP_REQUEST, trigger_type="machine"
+        ) as event:
+            # Use patch to mock the method instead of direct assignment
             with patch.object(
-                mock_sync_raw_mixin_with_jq_processor.entities_state_applier,
-                "upsert",
-                side_effect=upsert_side_effect,
+                mock_sync_raw_mixin_with_jq_processor.port_app_config_handler,
+                "get_port_app_config",
+                return_value=PortAppConfig(
+                    enable_merge_entity=True,
+                    delete_dependent_entities=True,
+                    create_missing_related_entities=False,
+                    resources=[mock_resource_config],
+                ),
             ):
-                # Call the register_raw method
-                registered_entities = (
-                    await mock_sync_raw_mixin_with_jq_processor.register_raw(
-                        kind, raw_entity, user_agent_type
-                    )
+                # Ensure the event.port_app_config is set correctly
+                event.port_app_config = await mock_sync_raw_mixin_with_jq_processor.port_app_config_handler.get_port_app_config(
+                    use_cache=False
                 )
 
-                # Assert that the registered entities match the expected results
-                assert len(registered_entities) == len(expected_result)
-                for entity, result in zip(registered_entities, expected_result):
-                    assert entity.identifier == result["identifier"]
-                    assert entity.blueprint == result["blueprint"]
-                    assert entity.properties == result["properties"]
+                def upsert_side_effect(
+                    entities: list[Entity], user_agent_type: UserAgentType
+                ) -> list[Entity]:
+                    # Simulate returning the passed entities
+                    return entities
+
+                # Patch the upsert method with the side effect
+                with patch.object(
+                    mock_sync_raw_mixin_with_jq_processor.entities_state_applier,
+                    "upsert",
+                    side_effect=upsert_side_effect,
+                ):
+                    # Call the register_raw method
+                    registered_entities = (
+                        await mock_sync_raw_mixin_with_jq_processor.register_raw(
+                            kind, raw_entity, user_agent_type
+                        )
+                    )
+
+                    # Assert that the registered entities match the expected results
+                    assert len(registered_entities) == len(expected_result)
+                    for entity, result in zip(registered_entities, expected_result):
+                        assert entity.identifier == result["identifier"]
+                        assert entity.blueprint == result["blueprint"]
+                        assert entity.properties == result["properties"]
 
 
 @pytest.mark.asyncio
 async def test_unregister_raw(
     mock_sync_raw_mixin_with_jq_processor: SyncRawMixin,
-    mock_ocean: Ocean,
     mock_context: PortOceanContext,
     monkeypatch: pytest.MonkeyPatch,
+    mock_resource_config: ResourceConfig,
 ) -> None:
     kind = "service"
     user_agent_type = UserAgentType.exporter
@@ -547,23 +530,7 @@ async def test_unregister_raw(
                 enable_merge_entity=True,
                 delete_dependent_entities=True,
                 create_missing_related_entities=False,
-                resources=[
-                    ResourceConfig(
-                        kind=kind,
-                        selector=Selector(query="true"),
-                        port=PortResourceConfig(
-                            entity=MappingsConfig(
-                                mappings=EntityMapping(
-                                    identifier=".id | tostring",
-                                    title=".name",
-                                    blueprint='"service"',
-                                    properties={"url": ".web_url"},
-                                    relations={},
-                                )
-                            )
-                        ),
-                    )
-                ],
+                resources=[mock_resource_config],
             ),
         ):
             # Ensure the event.port_app_config is set correctly
@@ -718,142 +685,92 @@ class CalculationResult:
 
 
 @pytest.mark.asyncio
-async def test_register_resource_raw_saas_no_changes_upsert_not_called_entitiy_is_returned(
-    mock_sync_raw_mixin: SyncRawMixin,
-    mock_port_app_config: PortAppConfig,
-    mock_context: PortOceanContext,
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    # Mock ocean.app.is_saas()
-    monkeypatch.setattr(mock_context.app, "is_saas", lambda: True)
-
-    # Mock dependencies
-    entity = Entity(identifier="1", blueprint="service")
-    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
-    mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([]))  # type: ignore
-    mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock()  # type: ignore
-
-    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
-        event.port_app_config = mock_port_app_config
-
-        # Test execution
-        result = await mock_sync_raw_mixin._register_resource_raw(
-            mock_port_app_config.resources[0],  # Use the first resource from the config
-            [{"some": "data"}],
-            UserAgentType.exporter,
-        )
-
-        # Assertions
-        assert len(result.entity_selector_diff.passed) == 1
-        mock_sync_raw_mixin._calculate_raw.assert_called_once()
-        mock_sync_raw_mixin.entities_state_applier.upsert.assert_not_called()
-        mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
-
-
-@pytest.mark.asyncio
-async def test_register_resource_raw_saas_with_changes_upsert_called_and_entities_are_mapped(
+async def test_register_resource_raw_no_changes_upsert_not_called_entitiy_is_returned(
     mock_sync_raw_mixin: SyncRawMixin,
     mock_port_app_config: PortAppConfig,
-    mock_context: PortOceanContext,
-    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    # Mock ocean.app.is_saas()
-    monkeypatch.setattr(mock_context.app, "is_saas", lambda: True)
-
-    # Mock dependencies
-    entity = Entity(identifier="1", blueprint="service")
-    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
-    mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([entity]))  # type: ignore
-    mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock(return_value=[entity])  # type: ignore
-
-    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
-        event.port_app_config = mock_port_app_config
-
-        # Test execution
-        result = await mock_sync_raw_mixin._register_resource_raw(
-            mock_port_app_config.resources[0],
-            [{"some": "data"}],
-            UserAgentType.exporter,
-        )
+    # Mock the integration settings with skip_check_diff
+    with patch.object(ocean.config.integration, "skip_check_diff", False):
+        entity = Entity(identifier="1", blueprint="service")
+        mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
+        mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([]))  # type: ignore
+        mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock()  # type: ignore
+
+        async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+            event.port_app_config = mock_port_app_config
+
+            # Test execution
+            result = await mock_sync_raw_mixin._register_resource_raw(
+                mock_port_app_config.resources[
+                    0
+                ],  # Use the first resource from the config
+                [{"some": "data"}],
+                UserAgentType.exporter,
+            )
 
-        # Assertions
-        assert len(result.entity_selector_diff.passed) == 1
-        mock_sync_raw_mixin._calculate_raw.assert_called_once()
-        mock_sync_raw_mixin.entities_state_applier.upsert.assert_called_once()
-        mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
+            # Assertions
+            assert len(result.entity_selector_diff.passed) == 1
+            mock_sync_raw_mixin._calculate_raw.assert_called_once()
+            mock_sync_raw_mixin.entities_state_applier.upsert.assert_not_called()
+            mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
 
 
 @pytest.mark.asyncio
-async def test_register_resource_raw_non_saas_upsert_called_and_no_entitites_diff_calculation(
+async def test_register_resource_raw_with_changes_upsert_called_and_entities_are_mapped(
     mock_sync_raw_mixin: SyncRawMixin,
     mock_port_app_config: PortAppConfig,
-    mock_context: PortOceanContext,
-    monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    # Mock ocean.app.is_saas()
-    monkeypatch.setattr(mock_context.app, "is_saas", lambda: False)
-
-    # Mock dependencies
-    entity = Entity(identifier="1", blueprint="service")
-    calculation_result = CalculationResult(
-        entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]),
-        errors=[],
-        misconfigurations=[],
-        misonfigured_entity_keys=[],
-    )
-    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[calculation_result])  # type: ignore
-    mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock()  # type: ignore
-    mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock(return_value=[entity])  # type: ignore
-
-    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
-        event.port_app_config = mock_port_app_config
-
-        # Test execution
-        result = await mock_sync_raw_mixin._register_resource_raw(
-            mock_port_app_config.resources[0],
-            [{"some": "data"}],
-            UserAgentType.exporter,
-        )
+    # Mock the integration settings with skip_check_diff
+    with patch.object(ocean.config.integration, "skip_check_diff", False):
+        entity = Entity(identifier="1", blueprint="service")
+        mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[entity], failed=[]), errors=[], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
+        mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([entity]))  # type: ignore
+        mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock(return_value=[entity])  # type: ignore
+
+        async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+            event.port_app_config = mock_port_app_config
+
+            # Test execution
+            result = await mock_sync_raw_mixin._register_resource_raw(
+                mock_port_app_config.resources[0],
+                [{"some": "data"}],
+                UserAgentType.exporter,
+            )
 
-        # Assertions
-        assert len(result.entity_selector_diff.passed) == 1
-        mock_sync_raw_mixin._calculate_raw.assert_called_once()
-        mock_sync_raw_mixin._map_entities_compared_with_port.assert_not_called()
-        mock_sync_raw_mixin.entities_state_applier.upsert.assert_called_once()
+            # Assertions
+            assert len(result.entity_selector_diff.passed) == 1
+            mock_sync_raw_mixin._calculate_raw.assert_called_once()
+            mock_sync_raw_mixin.entities_state_applier.upsert.assert_called_once()
+            mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
 
 
 @pytest.mark.asyncio
-async def test_register_resource_raw_saas_with_errors(
-    mock_sync_raw_mixin: SyncRawMixin,
-    mock_port_app_config: PortAppConfig,
-    mock_context: PortOceanContext,
-    monkeypatch: pytest.MonkeyPatch,
+async def test_register_resource_raw_with_errors(
+    mock_sync_raw_mixin: SyncRawMixin, mock_port_app_config: PortAppConfig
 ) -> None:
-    # Mock ocean.app.is_saas()
-    monkeypatch.setattr(mock_context.app, "is_saas", lambda: True)
-
-    # Mock dependencies
-    failed_entity = Entity(identifier="1", blueprint="service")
-    error = Exception("Test error")
-    mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[], failed=[failed_entity]), errors=[error], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
-    mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([]))  # type: ignore
-    mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock()  # type: ignore
-
-    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
-        event.port_app_config = mock_port_app_config
-
-        # Test execution
-        result = await mock_sync_raw_mixin._register_resource_raw(
-            mock_port_app_config.resources[0],
-            [{"some": "data"}],
-            UserAgentType.exporter,
-        )
+    # Mock the integration settings with skip_check_diff
+    with patch.object(ocean.config.integration, "skip_check_diff", False):
+        failed_entity = Entity(identifier="1", blueprint="service")
+        error = Exception("Test error")
+        mock_sync_raw_mixin._calculate_raw = AsyncMock(return_value=[CalculationResult(entity_selector_diff=EntitySelectorDiff(passed=[], failed=[failed_entity]), errors=[error], misconfigurations=[], misonfigured_entity_keys=[])])  # type: ignore
+        mock_sync_raw_mixin._map_entities_compared_with_port = AsyncMock(return_value=([]))  # type: ignore
+        mock_sync_raw_mixin.entities_state_applier.upsert = AsyncMock()  # type: ignore
+
+        async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+            event.port_app_config = mock_port_app_config
+
+            # Test execution
+            result = await mock_sync_raw_mixin._register_resource_raw(
+                mock_port_app_config.resources[0],
+                [{"some": "data"}],
+                UserAgentType.exporter,
+            )
 
-        # Assertions
-        assert len(result.entity_selector_diff.passed) == 0
-        assert len(result.entity_selector_diff.failed) == 1
-        assert len(result.errors) == 1
-        assert result.errors[0] == error
-        mock_sync_raw_mixin._calculate_raw.assert_called_once()
-        mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
-        mock_sync_raw_mixin.entities_state_applier.upsert.assert_not_called()
+            # Assertions
+            assert len(result.entity_selector_diff.passed) == 0
+            assert len(result.entity_selector_diff.failed) == 1
+            assert len(result.errors) == 1
+            assert result.errors[0] == error
+            mock_sync_raw_mixin._calculate_raw.assert_called_once()
+            mock_sync_raw_mixin._map_entities_compared_with_port.assert_called_once()
+            mock_sync_raw_mixin.entities_state_applier.upsert.assert_not_called()

{port_ocean-0.18.2.dist-info → port_ocean-0.18.4.dist-info}/METADATA

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

@@ -3,7 +3,7 @@ integrations/_infra/Dockerfile.alpine,sha256=iauglyEzz5uEPBxsN-9SLFr6qca3Tf4b0DP
 integrations/_infra/Dockerfile.base.builder,sha256=LwKLfJvQfKksMqacAT_aDQxFMC2Ty5fFKIa0Eu4QcCc,619
 integrations/_infra/Dockerfile.base.runner,sha256=dsjTWgLQFm4x5gcm-IPhwkDv-M6VRKwdf-qct457h2c,357
 integrations/_infra/Dockerfile.dockerignore,sha256=CM1Fxt3I2AvSvObuUZRmy5BNLSGC7ylnbpWzFgD4cso,1163
-integrations/_infra/Makefile,sha256=ofVvsebe7-inGBjZI976L6ghe1Z3RhKFvQhCf6clHn8,2142
+integrations/_infra/Makefile,sha256=NWX1QLd429KyCzvwNwpkWtSm5QTVarnh5SYO822-ea4,2360
 integrations/_infra/grpcio.sh,sha256=m924poYznoRZ6Tt7Ct8Cs5AV_cmmOx598yIZ3z4DvZE,616
 integrations/_infra/init.sh,sha256=nN8lTrOhB286UfFvD6sJ9YJ-9asT9zVSddQB-RAb7Z4,99
 port_ocean/__init__.py,sha256=J3Mqp7d-CkEe9eMigGG8gSEiVKICY2bf7csNEwVOXk0,294
@@ -46,19 +46,20 @@ 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=6-uDMWsJ0xLe1-9IoYXHWmwtufj8rJR4BCRXJlSkCSQ,3447
-port_ocean/clients/port/client.py,sha256=Xd8Jk25Uh4WXY_WW-z1Qbv6F3ZTBFPoOolsxHMfozKw,3366
+port_ocean/clients/port/client.py,sha256=OaNeN3U7Hw0tK4jYE6ESJEPKbTf9nGp2jcJVq00gnf8,3546
 port_ocean/clients/port/mixins/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/clients/port/mixins/blueprints.py,sha256=POBl4uDocrgJBw4rvCAzwRcD4jk-uBL6pDAuKMTajdg,4633
-port_ocean/clients/port/mixins/entities.py,sha256=_aEGE_kGOucw6ZH9qleM5Tjt-YiPAbq9rjSOwcI-py0,10677
-port_ocean/clients/port/mixins/integrations.py,sha256=t8OSa7Iopnpp8IOEcp3a7WgwOcJEBdFow9UbGDKWxKI,4858
+port_ocean/clients/port/mixins/entities.py,sha256=PJzVZTBW_OheFRGPRCZ6yPbVGEAKsMO9CNDNJUI1l48,10770
+port_ocean/clients/port/mixins/integrations.py,sha256=cOmHdR0NdU8dXMD-5w3OpSEPPbaND0jSjJ4BGcHDsJQ,6900
 port_ocean/clients/port/mixins/migrations.py,sha256=A6896oJF6WbFL2WroyTkMzr12yhVyWqGoq9dtLNSKBY,1457
+port_ocean/clients/port/mixins/organization.py,sha256=fCo_ZS8UlQXsyIx-odTuWkbnfcYmVnQfIsSyJuPOPjM,1031
 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=SjhgmJXAqH2JqXfGy8GoGwzUYiJvUhWDrJyxQcenxZc,2512
 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=cxGnOTO9cEwwFcTSzOmwMw1yPkQHniVJFyCQCyEZ6yY,4333
+port_ocean/config/settings.py,sha256=q5KgDIr8snIxejoKyWSyf21R_AYEEXiEd3-ry9qf3ss,5227
 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
@@ -69,7 +70,7 @@ port_ocean/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/defaults/__init__.py,sha256=8qCZg8n06WAdMu9s_FiRtDYLGPGHbOuS60vapeUoAks,142
 port_ocean/core/defaults/clean.py,sha256=TOVe5b5FAjFspAkQuKA70k2BClCEFbrQ3xgiAoKXKYE,2427
 port_ocean/core/defaults/common.py,sha256=zJsj7jvlqIMLGXhdASUlbKS8GIAf-FDKKB0O7jB6nx0,4166
-port_ocean/core/defaults/initialize.py,sha256=PVR0awQc0eFKKD5wldMpqg5IKtfc8llreZ1FDN3cCIE,8570
+port_ocean/core/defaults/initialize.py,sha256=IYgc6XS5ARdcPM4IQrCSi4cdAomHxJVnP_OWOU9f05U,10382
 port_ocean/core/event_listener/__init__.py,sha256=T3E52MKs79fNEW381p7zU9F2vOMvIiiTYWlqRUqnsg0,1135
 port_ocean/core/event_listener/base.py,sha256=VdIdp7RLOSxH3ICyV-wCD3NiJoUzsh2KkJ0a9B29GeI,2847
 port_ocean/core/event_listener/factory.py,sha256=M4Qi05pI840sjDIbdjUEgYe9Gp5ckoCkX-KgLBxUpZg,4096
@@ -101,9 +102,9 @@ port_ocean/core/integrations/mixins/__init__.py,sha256=FA1FEKMM6P-L2_m7Q4L20mFa4
 port_ocean/core/integrations/mixins/events.py,sha256=0jKRsBw6lU8Mqs7MaQK4n-t_H6Z4NEkXZ5VWzqTrKEc,2396
 port_ocean/core/integrations/mixins/handler.py,sha256=mZ7-0UlG3LcrwJttFbMe-R4xcOU2H_g33tZar7PwTv8,3771
 port_ocean/core/integrations/mixins/sync.py,sha256=B9fEs8faaYLLikH9GBjE_E61vo0bQDjIGQsQ1SRXOlA,3931
-port_ocean/core/integrations/mixins/sync_raw.py,sha256=Ke-wCBv2zVEgF-6QafXKRkmJ59qAsqSHr61XPfq19J8,24752
+port_ocean/core/integrations/mixins/sync_raw.py,sha256=XLxH9_OOudLW4Q5lrUWWpcXIM3KdEDnYwEEP661Rfao,24465
 port_ocean/core/integrations/mixins/utils.py,sha256=oN4Okz6xlaefpid1_Pud8HPSw9BwwjRohyNsknq-Myg,2309
-port_ocean/core/models.py,sha256=BDSylTaTMtisvFR2gM6gmRc-387tA0XZSFufKEYdk3A,2115
+port_ocean/core/models.py,sha256=FvTp-BlpbvLbMbngE0wsiimsCfmIhUR1PvsE__Z--1I,2206
 port_ocean/core/ocean_types.py,sha256=j_-or1VxDy22whLLxwxgzIsE4wAhFLH19Xff9l4oJA8,1124
 port_ocean/core/utils/entity_topological_sorter.py,sha256=MDUjM6OuDy4Xj68o-7InNN0w1jqjxeDfeY8U02vySNI,3081
 port_ocean/core/utils/utils.py,sha256=HmumOeH27N0NX1_OP3t4oGKt074ht9XyXhvfZ5I05s4,6474
@@ -114,7 +115,7 @@ port_ocean/exceptions/base.py,sha256=uY4DX7fIITDFfemCJDWpaZi3bD51lcANc5swpoNvMJA
 port_ocean/exceptions/clients.py,sha256=LKLLs-Zy3caNG85rwxfOw2rMr8qqVV6SHUq4fRCZ99U,180
 port_ocean/exceptions/context.py,sha256=mA8HII6Rl4QxKUz98ppy1zX3kaziaen21h1ZWuU3ADc,372
 port_ocean/exceptions/core.py,sha256=Zmb1m6NnkSPWpAiQA5tgejm3zpDMt1WQEN47OJNo54A,856
-port_ocean/exceptions/port_defaults.py,sha256=45Bno5JEB-GXztvKsy8mw7TrydQmw13-4JAo2oQmXkE,438
+port_ocean/exceptions/port_defaults.py,sha256=2a7Koy541KxMan33mU-gbauUxsumG3NT4itVxSpQqfw,666
 port_ocean/exceptions/utils.py,sha256=gjOqpi-HpY1l4WlMFsGA9yzhxDhajhoGGdDDyGbLnqI,197
 port_ocean/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/helpers/async_client.py,sha256=SRlP6o7_FCSY3UHnRlZdezppePVxxOzZ0z861vE3K40,1783
@@ -130,10 +131,11 @@ port_ocean/run.py,sha256=COoRSmLG4hbsjIW5DzhV0NYVegI9xHd1POv6sg4U1No,2217
 port_ocean/sonar-project.properties,sha256=X_wLzDOkEVmpGLRMb2fg9Rb0DxWwUFSvESId8qpvrPI,73
 port_ocean/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/tests/clients/port/mixins/test_entities.py,sha256=A9myrnkLhKSQrnOLv1Zz2wiOVSxW65Q9RIUIRbn_V7w,1586
+port_ocean/tests/clients/port/mixins/test_organization_mixin.py,sha256=-8iHM33Oe8PuyEfj3O_6Yob8POp4fSmB0hnIT0Gv-8Y,868
 port_ocean/tests/conftest.py,sha256=JXASSS0IY0nnR6bxBflhzxS25kf4iNaABmThyZ0mZt8,101
 port_ocean/tests/core/defaults/test_common.py,sha256=sR7RqB3ZYV6Xn6NIg-c8k5K6JcGsYZ2SCe_PYX5vLYM,5560
 port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py,sha256=FnEnaDjuoAbKvKyv6xJ46n3j0ZcaT70Sg2zc7oy7HAA,13596
-port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=-qipUqVvXLSdcbDKHOivTMPPaKqC1euQmAhmK4FbFIY,33926
+port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=SSf1ZRZVcIta9zfx2-SpYFc_-MoHPDJSa1MkbIx3icI,31172
 port_ocean/tests/core/test_utils.py,sha256=Z3kdhb5V7Svhcyy3EansdTpgHL36TL6erNtU-OPwAcI,2647
 port_ocean/tests/core/utils/test_entity_topological_sorter.py,sha256=zuq5WSPy_88PemG3mOUIHTxWMR_js1R7tOzUYlgBd68,3447
 port_ocean/tests/core/utils/test_resolve_entities_diff.py,sha256=4kTey1c0dWKbLXjJ-9m2GXrHyAWZeLQ2asdtYRRUdRs,16573
@@ -158,8 +160,8 @@ port_ocean/utils/repeat.py,sha256=0EFWM9d8lLXAhZmAyczY20LAnijw6UbIECf5lpGbOas,32
 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.18.2.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.18.2.dist-info/METADATA,sha256=sq2TAoAyAoHZePy8yYbv9qbqH25qJnaNff16I-guId0,6669
-port_ocean-0.18.2.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.18.2.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.18.2.dist-info/RECORD,,
+port_ocean-0.18.4.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.18.4.dist-info/METADATA,sha256=qe_3HL2F4NgoCId8n4gmLPqVUGKaOTU11XC05vMPO8I,6669
+port_ocean-0.18.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.18.4.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.18.4.dist-info/RECORD,,