port-ocean 0.20.3__py3-none-any.whl → 0.20.4__py3-none-any.whl

port_ocean/core/handlers/webhook/abstract_webhook_processor.py

@@ -109,9 +109,9 @@ class AbstractWebhookProcessor(ABC):
         pass
 
     @abstractmethod
-    def should_process_event(self, event: WebhookEvent) -> bool:
+    async def should_process_event(self, event: WebhookEvent) -> bool:
         pass
 
     @abstractmethod
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         pass

port_ocean/core/handlers/webhook/processor_manager.py

@@ -47,7 +47,7 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
             except Exception as e:
                 logger.exception(f"Error starting queue processor for {path}: {str(e)}")
 
-    def _extract_matching_processors(
+    async def _extract_matching_processors(
         self, webhook_event: WebhookEvent, path: str
     ) -> list[tuple[ResourceConfig, AbstractWebhookProcessor]]:
         """Find and extract the matching processor for an event"""
@@ -56,8 +56,8 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
 
         for processor_class in self._processors_classes[path]:
             processor = processor_class(webhook_event.clone())
-            if processor.should_process_event(webhook_event):
-                kinds = processor.get_matching_kinds(webhook_event)
+            if await processor.should_process_event(webhook_event):
+                kinds = await processor.get_matching_kinds(webhook_event)
                 for kind in kinds:
                     for resource in event.port_app_config.resources:
                         if resource.kind == kind:
@@ -92,26 +92,30 @@ class LiveEventsProcessorManager(LiveEventsMixin, EventsMixin):
                         parent_override=webhook_event.event_context,
                     ):
                         matching_processors_with_resource = (
-                            self._extract_matching_processors(webhook_event, path)
+                            await self._extract_matching_processors(webhook_event, path)
                         )
                         webhook_event_raw_results_for_all_resources = await asyncio.gather(
                             *(
                                 self._process_single_event(processor, path, resource)
                                 for resource, processor in matching_processors_with_resource
-                            )
+                            ),
+                            return_exceptions=True,
                         )
-                        if webhook_event_raw_results_for_all_resources and all(
-                            webhook_event_raw_results_for_all_resources
-                        ):
+
+                        successful_raw_results: list[WebhookEventRawResults] = [
+                            result
+                            for result in webhook_event_raw_results_for_all_resources
+                            if isinstance(result, WebhookEventRawResults)
+                        ]
+
+                        if successful_raw_results:
                             logger.info(
                                 "Exporting raw event results to entities",
                                 webhook_event_raw_results_for_all_resources_length=len(
-                                    webhook_event_raw_results_for_all_resources
+                                    successful_raw_results
                                 ),
                             )
-                            await self.sync_raw_results(
-                                webhook_event_raw_results_for_all_resources
-                            )
+                            await self.sync_raw_results(successful_raw_results)
             except asyncio.CancelledError:
                 logger.info(f"Queue processor for {path} is shutting down")
                 for _, processor in matching_processors_with_resource:

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

@@ -32,7 +32,7 @@ class ConcreteWebhookProcessor(AbstractWebhookProcessor):
     ) -> WebhookEventRawResults:
         return WebhookEventRawResults(updated_raw_results=[{}], deleted_raw_results=[])
 
-    def should_process_event(self, webhook_event: WebhookEvent) -> bool:
+    async def should_process_event(self, webhook_event: WebhookEvent) -> bool:
         return True
 
     async def before_processing(self) -> None:
@@ -47,7 +47,7 @@ class ConcreteWebhookProcessor(AbstractWebhookProcessor):
         await super().cancel()
         self.cancel_called = True
 
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         return ["test"]
 
 

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

@@ -54,10 +54,10 @@ class MockProcessor(AbstractWebhookProcessor):
     ) -> WebhookEventRawResults:
         return WebhookEventRawResults(updated_raw_results=[], deleted_raw_results=[])
 
-    def should_process_event(self, event: WebhookEvent) -> bool:
+    async def should_process_event(self, event: WebhookEvent) -> bool:
         return True
 
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         return ["repository"]
 
 
@@ -75,10 +75,10 @@ class MockProcessorFalse(AbstractWebhookProcessor):
     ) -> WebhookEventRawResults:
         return WebhookEventRawResults(updated_raw_results=[], deleted_raw_results=[])
 
-    def should_process_event(self, event: WebhookEvent) -> bool:
+    async def should_process_event(self, event: WebhookEvent) -> bool:
         return False
 
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         return ["repository"]
 
 
@@ -110,10 +110,10 @@ class MockWebhookProcessor(AbstractWebhookProcessor):
     async def cancel(self) -> None:
         self.cancel_called = True
 
-    def should_process_event(self, event: WebhookEvent) -> bool:
+    async def should_process_event(self, event: WebhookEvent) -> bool:
         return True
 
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         return ["test"]
 
 
@@ -155,10 +155,10 @@ class MockWebhookHandlerForProcessWebhookRequest(AbstractWebhookProcessor):
         self.handled = True
         return WebhookEventRawResults(updated_raw_results=[], deleted_raw_results=[])
 
-    def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+    async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
         return ["repository"]
 
-    def should_process_event(self, event: WebhookEvent) -> bool:
+    async def should_process_event(self, event: WebhookEvent) -> bool:
         """Filter the event data before processing."""
         return True
 
@@ -329,16 +329,16 @@ async def test_extractMatchingProcessors_processorMatch(
 
     async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
         event.port_app_config = mock_port_app_config
-        processors = processor_manager._extract_matching_processors(
+        processors = await processor_manager._extract_matching_processors(
             webhook_event, test_path
         )
 
-    assert len(processors) == 1
-    config, processor = processors[0]
-    assert isinstance(processor, MockProcessor)
-    assert config.kind == "repository"
-    assert processor.event != webhook_event
-    assert processor.event.payload == webhook_event.payload
+        assert len(processors) == 1
+        config, processor = processors[0]
+        assert isinstance(processor, MockProcessor)
+        assert config.kind == "repository"
+        assert processor.event != webhook_event
+        assert processor.event.payload == webhook_event.payload
 
 
 @pytest.mark.asyncio
@@ -355,7 +355,9 @@ async def test_extractMatchingProcessors_noMatch(
             EventType.HTTP_REQUEST, trigger_type="request"
         ) as event:
             event.port_app_config = mock_port_app_config
-            processor_manager._extract_matching_processors(webhook_event, test_path)
+            await processor_manager._extract_matching_processors(
+                webhook_event, test_path
+            )
 
 
 @pytest.mark.asyncio
@@ -370,7 +372,7 @@ async def test_extractMatchingProcessors_multipleMatches(
 
     async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
         event.port_app_config = mock_port_app_config
-        processors = processor_manager._extract_matching_processors(
+        processors = await processor_manager._extract_matching_processors(
             webhook_event, test_path
         )
 
@@ -391,7 +393,7 @@ async def test_extractMatchingProcessors_onlyOneMatches(
 
     async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
         event.port_app_config = mock_port_app_config
-        processors = processor_manager._extract_matching_processors(
+        processors = await processor_manager._extract_matching_processors(
             webhook_event, test_path
         )
 
@@ -542,10 +544,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessed_en
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
@@ -649,10 +651,10 @@ async def test_integrationTest_postRequestSent_reachedTimeout_entityNotUpserted(
                 updated_raw_results=[], deleted_raw_results=[]
             )
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
@@ -766,20 +768,20 @@ async def test_integrationTest_postRequestSent_noMatchingHandlers_entityNotUpser
             )
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return False
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
     original_process_data = LiveEventsProcessorManager._extract_matching_processors
 
-    def patched_extract_matching_processors(
+    async def patched_extract_matching_processors(
         self: LiveEventsProcessorManager, event: WebhookEvent, path: str
     ) -> list[tuple[ResourceConfig, AbstractWebhookProcessor]]:
         try:
-            return original_process_data(self, event, path)
+            return await original_process_data(self, event, path)
         except Exception as e:
             test_state["exception_thrown"] = e  # type: ignore
             return []
@@ -882,10 +884,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedFor
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     class TestProcessorB(AbstractWebhookProcessor):
@@ -913,10 +915,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedFor
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     class TestProcessorFiltersOut(AbstractWebhookProcessor):
@@ -944,10 +946,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedFor
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return False
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
@@ -1071,10 +1073,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedwit
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
@@ -1195,10 +1197,10 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedwit
             processed_events.append(event_data)
             return event_data
 
-        def should_process_event(self, event: WebhookEvent) -> bool:
+        async def should_process_event(self, event: WebhookEvent) -> bool:
             return True
 
-        def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
             return ["repository"]
 
     processing_complete = asyncio.Event()
@@ -1262,3 +1264,139 @@ async def test_integrationTest_postRequestSent_webhookEventRawResultProcessedwit
     mock_delete.assert_not_called()
 
     await mock_context.app.webhook_manager.shutdown()
+
+
+@pytest.mark.asyncio
+@patch(
+    "port_ocean.core.handlers.entities_state_applier.port.applier.HttpEntitiesStateApplier.upsert"
+)
+@patch(
+    "port_ocean.core.handlers.entities_state_applier.port.applier.HttpEntitiesStateApplier.delete"
+)
+async def test_integrationTest_postRequestSent_oneProcessorThrowsException_onlySuccessfulResultsProcessed(
+    mock_delete: AsyncMock,
+    mock_upsert: AsyncMock,
+    mock_context: PortOceanContext,
+    mock_port_app_config: PortAppConfig,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Integration test for webhook processing where one processor throws an exception"""
+
+    monkeypatch.setattr(
+        "port_ocean.core.integrations.mixins.handler.ocean", mock_context
+    )
+    monkeypatch.setattr(
+        "port_ocean.core.integrations.mixins.live_events.ocean", mock_context
+    )
+    processed_events: list[WebhookEventRawResults] = []
+    mock_upsert.return_value = [entity]
+
+    class SuccessfulProcessor(AbstractWebhookProcessor):
+        async def authenticate(
+            self, payload: Dict[str, Any], headers: Dict[str, str]
+        ) -> bool:
+            return True
+
+        async def validate_payload(self, payload: Dict[str, Any]) -> bool:
+            return True
+
+        async def handle_event(
+            self, payload: EventPayload, resource: ResourceConfig
+        ) -> WebhookEventRawResults:
+            event_data = WebhookEventRawResults(
+                updated_raw_results=[
+                    {
+                        "name": "repo-one",
+                        "links": {"html": {"href": "https://example.com/repo-one"}},
+                        "main_branch": "main",
+                    }
+                ],
+                deleted_raw_results=[],
+            )
+            processed_events.append(event_data)
+            return event_data
+
+        async def should_process_event(self, event: WebhookEvent) -> bool:
+            return True
+
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+            return ["repository"]
+
+    class FailingProcessor(AbstractWebhookProcessor):
+        async def authenticate(
+            self, payload: Dict[str, Any], headers: Dict[str, str]
+        ) -> bool:
+            return True
+
+        async def validate_payload(self, payload: Dict[str, Any]) -> bool:
+            return True
+
+        async def handle_event(
+            self, payload: EventPayload, resource: ResourceConfig
+        ) -> WebhookEventRawResults:
+            raise ValueError("Simulated failure in processor")
+
+        async def should_process_event(self, event: WebhookEvent) -> bool:
+            return True
+
+        async def get_matching_kinds(self, event: WebhookEvent) -> list[str]:
+            return ["repository"]
+
+    processing_complete = asyncio.Event()
+    original_process_data = LiveEventsMixin.sync_raw_results
+
+    async def patched_export_single_resource(
+        self: LiveEventsMixin, webhookEventRawResults: list[WebhookEventRawResults]
+    ) -> None:
+        try:
+            await original_process_data(self, webhookEventRawResults)
+        except Exception as e:
+            raise e
+        finally:
+            processing_complete.set()
+
+    monkeypatch.setattr(
+        LiveEventsMixin,
+        "sync_raw_results",
+        patched_export_single_resource,
+    )
+    test_path = "/webhook-test"
+    mock_context.app.integration = BaseIntegration(ocean)
+    mock_context.app.webhook_manager = LiveEventsProcessorManager(
+        mock_context.app.integration_router, SignalHandler()
+    )
+
+    # Register both processors
+    mock_context.app.webhook_manager.register_processor(test_path, SuccessfulProcessor)
+    mock_context.app.webhook_manager.register_processor(test_path, FailingProcessor)
+    await mock_context.app.webhook_manager.start_processing_event_messages()
+    mock_context.app.fast_api_app.include_router(
+        mock_context.app.webhook_manager._router
+    )
+    client = TestClient(mock_context.app.fast_api_app)
+
+    test_payload = {"test": "data"}
+
+    async with event_context(EventType.HTTP_REQUEST, trigger_type="request") as event:
+        mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config = AsyncMock(return_value=mock_port_app_config)  # type: ignore
+        event.port_app_config = (
+            await mock_context.app.webhook_manager.port_app_config_handler.get_port_app_config()
+        )
+
+        response = client.post(
+            test_path, json=test_payload, headers={"Content-Type": "application/json"}
+        )
+
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
+    try:
+        await asyncio.wait_for(processing_complete.wait(), timeout=10.0)
+    except asyncio.TimeoutError:
+        pytest.fail("Event processing timed out")
+
+    assert len(processed_events) == 1
+    assert mock_upsert.call_count == 1
+    mock_delete.assert_not_called()
+
+    await mock_context.app.webhook_manager.shutdown()

{port_ocean-0.20.3.dist-info → port_ocean-0.20.4.dist-info}/METADATA

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

@@ -103,8 +103,8 @@ port_ocean/core/handlers/queue/local_queue.py,sha256=EzqsGIX43xbVAcePwTcCg5QDrXA
 port_ocean/core/handlers/resync_state_updater/__init__.py,sha256=kG6y-JQGpPfuTHh912L_bctIDCzAK4DN-d00S7rguWU,81
 port_ocean/core/handlers/resync_state_updater/updater.py,sha256=Yg9ET6ZV5B9GW7u6zZA6GlB_71kmvxvYX2FWgQNzMvo,3182
 port_ocean/core/handlers/webhook/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/core/handlers/webhook/abstract_webhook_processor.py,sha256=YRMr4M1m0XNZbxNGU0bzB3hEkPat1HCom66EU9NRffU,3879
-port_ocean/core/handlers/webhook/processor_manager.py,sha256=RoPV3cHjAv7jJ_vpC9y2fF2v9eb41h0VM6bNAPuzKdg,11779
+port_ocean/core/handlers/webhook/abstract_webhook_processor.py,sha256=5KwZkdkDd5HdVkXPzKiqabodZKl-hOtMypkTKd8Hq3M,3891
+port_ocean/core/handlers/webhook/processor_manager.py,sha256=Pmg81IT0i3MCFWC6648Ln4NfpAWvpyrPZwOFfdTPkDE,11928
 port_ocean/core/handlers/webhook/webhook_event.py,sha256=Iuw6IX3PPjwHECUeFgrJl6K249mJ-DPAGhP8OMxbc1c,4096
 port_ocean/core/integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/core/integrations/base.py,sha256=eS0WDOfCTim1UOQQrNuP14I6hvT_fr8dof_cr1ls01s,3107
@@ -156,8 +156,8 @@ port_ocean/tests/core/handlers/mixins/test_sync_raw.py,sha256=gxQ4e9hQuMS8-o5Ubi
 port_ocean/tests/core/handlers/port_app_config/test_api.py,sha256=eJZ6SuFBLz71y4ca3DNqKag6d6HUjNJS0aqQPwiLMTI,1999
 port_ocean/tests/core/handlers/port_app_config/test_base.py,sha256=tdjpFUnUZ6TNMxc3trKkzmMTGTb7oKIeu3rRXv_fV3g,6872
 port_ocean/tests/core/handlers/queue/test_local_queue.py,sha256=9Ly0HzZXbs6Rbl_bstsIdInC3h2bgABU3roP9S_PnJM,2582
-port_ocean/tests/core/handlers/webhook/test_abstract_webhook_processor.py,sha256=lLOVjjUCI973d9Ps_hugWOjyxNgEiPjqZVqN3qC2Rhs,3328
-port_ocean/tests/core/handlers/webhook/test_processor_manager.py,sha256=jwoimtQqrzro2Q2wBUmtKWN2bg9013GRpm7LEPCix80,44109
+port_ocean/tests/core/handlers/webhook/test_abstract_webhook_processor.py,sha256=zKwHhPAYEZoZ5Z2UETp1t--mbkS8uyvlXThB0obZTTc,3340
+port_ocean/tests/core/handlers/webhook/test_processor_manager.py,sha256=Nb-3VXVRol9fM5pLZQ1iGyPsZcHkWSNGG3bDHWjuR3Y,49285
 port_ocean/tests/core/handlers/webhook/test_webhook_event.py,sha256=oR4dEHLO65mp6rkfNfszZcfFoRZlB8ZWee4XetmsuIk,3181
 port_ocean/tests/core/test_utils.py,sha256=Z3kdhb5V7Svhcyy3EansdTpgHL36TL6erNtU-OPwAcI,2647
 port_ocean/tests/core/utils/test_entity_topological_sorter.py,sha256=zuq5WSPy_88PemG3mOUIHTxWMR_js1R7tOzUYlgBd68,3447
@@ -184,8 +184,8 @@ port_ocean/utils/repeat.py,sha256=U2OeCkHPWXmRTVoPV-VcJRlQhcYqPWI5NfmPlb1JIbc,32
 port_ocean/utils/signal.py,sha256=mMVq-1Ab5YpNiqN4PkiyTGlV_G0wkUDMMjTZp5z3pb0,1514
 port_ocean/utils/time.py,sha256=pufAOH5ZQI7gXvOvJoQXZXZJV-Dqktoj9Qp9eiRwmJ4,1939
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.20.3.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.20.3.dist-info/METADATA,sha256=etjLtg8n350AlzlWET_M8HSbFlYiDwx2mb9vYIbihJk,6669
-port_ocean-0.20.3.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.20.3.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.20.3.dist-info/RECORD,,
+port_ocean-0.20.4.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.20.4.dist-info/METADATA,sha256=TTDuej8wAckEOTu_3qM4GmnO0ReLwaN2SY7SSZ74pXw,6669
+port_ocean-0.20.4.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.20.4.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.20.4.dist-info/RECORD,,