port-ocean 0.28.17__tar.gz → 0.28.19__tar.gz

{port_ocean-0.28.17 → port_ocean-0.28.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.28.17
+Version: 0.28.19
 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.28.17 → port_ocean-0.28.19}/port_ocean/core/integrations/mixins/utils.py

@@ -1,11 +1,20 @@
-from contextlib import contextmanager
-from typing import Awaitable, Generator, Callable, cast
-
-from loguru import logger
 import asyncio
+import json
 import multiprocessing
+import os
 import re
-import json
+import shutil
+import stat
+import subprocess
+import tempfile
+from contextlib import contextmanager
+from typing import Any, AsyncGenerator, Awaitable, Callable, Generator, cast
+
+import ijson
+from loguru import logger
+
+from port_ocean.clients.port.utils import _http_client as _port_http_client
+from port_ocean.context.ocean import ocean
 from port_ocean.core.handlers.entity_processor.jq_entity_processor import JQEntityProcessor
 from port_ocean.core.ocean_types import (
     ASYNC_GENERATOR_RESYNC_TYPE,
@@ -19,16 +28,8 @@ from port_ocean.exceptions.core import (
     OceanAbortException,
     KindNotImplementedException,
 )
-import os
-from port_ocean.utils.async_http import _http_client
-from port_ocean.clients.port.utils import _http_client as _port_http_client
 from port_ocean.helpers.metric.metric import MetricType, MetricPhase
-from port_ocean.context.ocean import ocean
-import subprocess
-import tempfile
-import stat
-import ijson
-from typing import Any, AsyncGenerator
+from port_ocean.utils.async_http import _http_client
 
 def _process_path_type_items(
     result: RAW_RESULT, items_to_parse: str | None = None
@@ -216,7 +217,9 @@ async def get_items_to_parse_bulks(raw_data: dict[Any, Any], data_path: str, ite
       | map({{{items_to_parse_name}: ., {base_jq_object_string}}})"""
 
         # Use subprocess with list arguments instead of shell=True
-        jq_args = ["/bin/jq", jq_expression, data_path]
+
+        jq_path = shutil.which("jq") or "/bin/jq"
+        jq_args = [jq_path, jq_expression, data_path]
 
         with open(temp_output_path, "w") as output_file:
             result = subprocess.run(
@@ -271,7 +274,7 @@ def get_events_as_a_stream(
         max_buffer_size_mb: int = 1
     ) -> Generator[list[dict[str, Any]], None, None]:
         events = ijson.sendable_list()
-        coro = ijson.items_coro(events, target_items)
+        coro = ijson.items_coro(events, target_items, use_float=True)
 
         # Convert MB to bytes for the buffer size
         buffer_size = max_buffer_size_mb * 1024 * 1024

{port_ocean-0.28.17 → port_ocean-0.28.19}/port_ocean/helpers/retry.py

@@ -257,7 +257,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             else:
                 response = await transport.handle_async_request(request)
 
-            await self._log_response_size_async(request, response)
+            self._log_response_size(request, response)
 
             return response
         except Exception as e:
@@ -345,35 +345,6 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             return int(content_length)
         return None
 
-    async def _log_response_size_async(
-        self, request: httpx.Request, response: httpx.Response
-    ) -> None:
-        """Log the size of the response."""
-        if not self._should_log_response_size(request):
-            return
-
-        # Try to get content length from headers first
-        content_length = self._get_content_length(response)
-        if content_length is not None:
-            size_info = content_length
-        else:
-            # If no Content-Length header, try to get actual content size
-            try:
-                content = await response.aread()
-                actual_size = len(content)
-                size_info = actual_size
-                # Restore the cached body so downstream code can still use .json()/.text/.content
-                response._content = content  # httpx convention
-            except Exception as e:
-                cast(logging.Logger, self._logger).error(
-                    f"Error getting response size: {e}"
-                )
-                return
-
-        cast(logging.Logger, self._logger).info(
-            f"Response for {request.method} {request.url} - Size: {size_info} bytes"
-        )
-
     def _log_response_size(
         self, request: httpx.Request, response: httpx.Response
     ) -> None:
@@ -381,24 +352,11 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             return
 
         content_length = self._get_content_length(response)
-        if content_length is not None:
-            size_info = content_length
-        else:
-            # If no Content-Length header, try to get actual content size
-            try:
-                content = response.read()
-                actual_size = len(content)
-                size_info = actual_size
-                # Restore the cached body so downstream code can still use .json()/.text/.content
-                response._content = content  # httpx convention
-            except Exception as e:
-                cast(logging.Logger, self._logger).error(
-                    f"Error getting response size: {e}"
-                )
-                return
+        if content_length is None:
+            return
 
         cast(logging.Logger, self._logger).info(
-            f"Response for {request.method} {request.url} - Size: {size_info} bytes"
+            f"Response for {request.method} {request.url} - Size: {content_length} bytes"
         )
 
     async def _should_retry_async(self, response: httpx.Response) -> bool:

{port_ocean-0.28.17 → port_ocean-0.28.19}/port_ocean/log/logger_setup.py

@@ -61,9 +61,9 @@ def _http_loguru_handler(level: LogLevelType) -> None:
 
     http_memory_handler = HTTPMemoryHandler()
     signal_handler.register(
-        http_memory_handler.wait_for_lingering_threads, priority=-200
+        http_memory_handler.wait_for_lingering_threads, priority=-900
     )
-    signal_handler.register(http_memory_handler.flush, priority=-200)
+    signal_handler.register(http_memory_handler.flush, priority=-899)
 
     queue_listener = QueueListener(queue, http_memory_handler)
     queue_listener.start()

{port_ocean-0.28.17 → port_ocean-0.28.19}/port_ocean/tests/helpers/test_retry.py

@@ -1,5 +1,5 @@
 import pytest
-from unittest.mock import Mock, AsyncMock, patch
+from unittest.mock import Mock, patch
 from http import HTTPStatus
 import httpx
 
@@ -417,7 +417,7 @@ class TestResponseSizeLogging:
 
     @patch("port_ocean.helpers.retry.cast")
     def test_log_response_size_without_content_length(self, mock_cast: Mock) -> None:
-        """Test _log_response_size reads content when no Content-Length header."""
+        """Test _log_response_size does nothing when no Content-Length header."""
         mock_transport = Mock()
         mock_logger = Mock()
         mock_cast.return_value = mock_logger
@@ -432,38 +432,14 @@ class TestResponseSizeLogging:
 
         mock_response = Mock()
         mock_response.headers = {}
-        mock_response.read.return_value = b"test content"
 
         transport._log_response_size(mock_request, mock_response)
 
-        mock_response.read.assert_called_once()
-        mock_logger.info.assert_called_once_with(
-            "Response for POST https://api.example.com/create - Size: 12 bytes"
-        )
-
-    @patch("port_ocean.helpers.retry.cast")
-    def test_log_response_size_read_error(self, mock_cast: Mock) -> None:
-        """Test _log_response_size handles read errors gracefully."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.method = "GET"
-        mock_request.url.host = "api.example.com"
-
-        mock_response = Mock()
-        mock_response.headers = {}
-        mock_response.read.side_effect = Exception("Read error")
-
-        transport._log_response_size(mock_request, mock_response)
-
-        mock_logger.error.assert_called_once_with(
-            "Error getting response size: Read error"
-        )
+        mock_response.read.assert_not_called()
         mock_logger.info.assert_not_called()
 
+    # Read error path removed since _log_response_size no longer reads body
+
     @patch("port_ocean.helpers.retry.cast")
     def test_log_response_size_skips_when_should_not_log(self, mock_cast: Mock) -> None:
         """Test _log_response_size skips logging when _should_log_response_size returns False."""
@@ -482,166 +458,6 @@ class TestResponseSizeLogging:
 
         mock_logger.info.assert_not_called()
 
-    @pytest.mark.asyncio
-    @patch("port_ocean.helpers.retry.cast")
-    async def test_log_response_size_async_with_content_length(
-        self, mock_cast: Mock
-    ) -> None:
-        """Test _log_response_size_async logs when Content-Length header is present."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.method = "GET"
-        mock_url = Mock()
-        mock_url.host = "api.example.com"
-        mock_url.configure_mock(__str__=lambda self: "https://api.example.com/data")
-        mock_request.url = mock_url
-
-        mock_response = Mock()
-        mock_response.headers = {"Content-Length": "1024"}
-
-        await transport._log_response_size_async(mock_request, mock_response)
-
-        mock_logger.info.assert_called_once_with(
-            "Response for GET https://api.example.com/data - Size: 1024 bytes"
-        )
-
-    @pytest.mark.asyncio
-    @patch("port_ocean.helpers.retry.cast")
-    async def test_log_response_size_async_without_content_length(
-        self, mock_cast: Mock
-    ) -> None:
-        """Test _log_response_size_async reads content when no Content-Length header."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.method = "POST"
-        mock_url = Mock()
-        mock_url.host = "api.example.com"
-        mock_url.configure_mock(__str__=lambda self: "https://api.example.com/create")
-        mock_request.url = mock_url
-
-        mock_response = Mock()
-        mock_response.headers = {}
-        mock_response.aread = AsyncMock(return_value=b"test content")
-
-        await transport._log_response_size_async(mock_request, mock_response)
-
-        mock_response.aread.assert_called_once()
-        mock_logger.info.assert_called_once_with(
-            "Response for POST https://api.example.com/create - Size: 12 bytes"
-        )
-
-    @pytest.mark.asyncio
-    @patch("port_ocean.helpers.retry.cast")
-    async def test_log_response_size_async_read_error(self, mock_cast: Mock) -> None:
-        """Test _log_response_size_async handles read errors gracefully."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.method = "GET"
-        mock_request.url.host = "api.example.com"
-
-        mock_response = Mock()
-        mock_response.headers = {}
-        mock_response.aread = AsyncMock(side_effect=Exception("Async read error"))
-
-        await transport._log_response_size_async(mock_request, mock_response)
-
-        mock_logger.error.assert_called_once_with(
-            "Error getting response size: Async read error"
-        )
-        mock_logger.info.assert_not_called()
-
-    @pytest.mark.asyncio
-    @patch("port_ocean.helpers.retry.cast")
-    async def test_log_response_size_async_skips_when_should_not_log(
-        self, mock_cast: Mock
-    ) -> None:
-        """Test _log_response_size_async skips logging when _should_log_response_size returns False."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.url.host = "api.getport.io"  # This should skip logging
-
-        mock_response = Mock()
-        mock_response.headers = {"Content-Length": "1024"}
-
-        await transport._log_response_size_async(mock_request, mock_response)
-
-        mock_logger.info.assert_not_called()
-
-    @pytest.mark.asyncio
-    @patch("port_ocean.helpers.retry.cast")
-    async def test_log_response_size_async_restores_content(
-        self, mock_cast: Mock
-    ) -> None:
-        """Test _log_response_size_async restores response content after reading."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.method = "GET"
-        mock_url = Mock()
-        mock_url.host = "api.example.com"
-        mock_url.configure_mock(__str__=lambda self: "https://api.example.com/data")
-        mock_request.url = mock_url
-
-        test_content = b"test response content"
-        mock_response = Mock()
-        mock_response.headers = {}
-        mock_response.aread = AsyncMock(return_value=test_content)
-
-        await transport._log_response_size_async(mock_request, mock_response)
-
-        # Verify that the content was restored to the response
-        assert mock_response._content == test_content
-        mock_logger.info.assert_called_once_with(
-            "Response for GET https://api.example.com/data - Size: 21 bytes"
-        )
-
-    @patch("port_ocean.helpers.retry.cast")
-    def test_log_response_size_restores_content(self, mock_cast: Mock) -> None:
-        """Test _log_response_size restores response content after reading."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.method = "GET"
-        mock_url = Mock()
-        mock_url.host = "api.example.com"
-        mock_url.configure_mock(__str__=lambda self: "https://api.example.com/data")
-        mock_request.url = mock_url
-
-        test_content = b"test response content"
-        mock_response = Mock()
-        mock_response.headers = {}
-        mock_response.read.return_value = test_content
-
-        transport._log_response_size(mock_request, mock_response)
-
-        # Verify that the content was restored to the response
-        assert mock_response._content == test_content
-        mock_logger.info.assert_called_once_with(
-            "Response for GET https://api.example.com/data - Size: 21 bytes"
-        )
-
 
 class TestResponseSizeLoggingIntegration:
     """Integration tests to verify response consumption works after size logging."""
@@ -655,7 +471,7 @@ class TestResponseSizeLoggingIntegration:
     def test_log_response_size_preserves_json_consumption(
         self, mock_cast: Mock
     ) -> None:
-        """Test that _log_response_size preserves response for .json() consumption."""
+        """When no Content-Length, no logging/reading occurs; response usable."""
         mock_transport = Mock()
         mock_logger = Mock()
         mock_cast.return_value = mock_logger
@@ -665,26 +481,16 @@ class TestResponseSizeLoggingIntegration:
         mock_request.method = "GET"
         mock_request.url.host = "api.example.com"
 
-        # Create a mock response with JSON content
-        json_content = b'{"message": "test", "data": [1, 2, 3]}'
         mock_response = Mock()
-        mock_response.headers = {}  # No Content-Length header to force content reading
-        mock_response.read.return_value = json_content
+        mock_response.headers = {}
         mock_response.json.return_value = {"message": "test", "data": [1, 2, 3]}
 
-        # Call the logging function
         transport._log_response_size(mock_request, mock_response)
 
-        # Verify logging occurred
-        mock_logger.info.assert_called_once()
-
-        # Verify that response.json() can still be called without StreamConsumed error
+        mock_logger.info.assert_not_called()
         result = mock_response.json()
         assert result == {"message": "test", "data": [1, 2, 3]}
-
-        # Verify that read was called and content was restored
-        mock_response.read.assert_called_once()
-        assert mock_response._content == json_content
+        mock_response.read.assert_not_called()
 
     @patch("port_ocean.helpers.retry.cast")
     def test_log_response_size_with_content_length_preserves_json(
@@ -718,83 +524,11 @@ class TestResponseSizeLoggingIntegration:
         # Verify that read was NOT called since we had Content-Length
         mock_response.read.assert_not_called()
 
-    @pytest.mark.asyncio
-    @patch("port_ocean.helpers.retry.cast")
-    async def test_log_response_size_async_preserves_json_consumption(
-        self, mock_cast: Mock
-    ) -> None:
-        """Test that _log_response_size_async preserves response for .json() consumption."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.method = "GET"
-        mock_request.url.host = "api.example.com"
-
-        # Create a mock response with JSON content
-        json_content = b'{"users": [{"name": "John", "age": 30}]}'
-        mock_response = Mock()
-        mock_response.headers = {}  # No Content-Length header to force content reading
-        mock_response.aread = AsyncMock(return_value=json_content)
-        mock_response.json.return_value = {"users": [{"name": "John", "age": 30}]}
-
-        # Call the async logging function
-        await transport._log_response_size_async(mock_request, mock_response)
-
-        # Verify logging occurred
-        mock_logger.info.assert_called_once()
-
-        # Verify that response.json() can still be called without StreamConsumed error
-        result = mock_response.json()
-        assert result == {"users": [{"name": "John", "age": 30}]}
-
-        # Verify that aread was called and content was restored
-        mock_response.aread.assert_called_once()
-        assert mock_response._content == json_content
-
-    @pytest.mark.asyncio
-    @patch("port_ocean.helpers.retry.cast")
-    async def test_log_response_size_async_with_content_length_preserves_json(
-        self, mock_cast: Mock
-    ) -> None:
-        """Test that _log_response_size_async with Content-Length header preserves JSON consumption."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.method = "PUT"
-        mock_request.url.host = "api.example.com"
-
-        # Create a mock response with Content-Length header
-        mock_response = Mock()
-        mock_response.headers = {"Content-Length": "2048"}
-        mock_response.json.return_value = {
-            "updated": True,
-            "timestamp": "2023-12-01T12:00:00Z",
-        }
-
-        # Call the async logging function
-        await transport._log_response_size_async(mock_request, mock_response)
-
-        # Verify logging occurred
-        mock_logger.info.assert_called_once()
-
-        # Verify that response.json() can still be called
-        result = mock_response.json()
-        assert result == {"updated": True, "timestamp": "2023-12-01T12:00:00Z"}
-
-        # Verify that aread was NOT called since we had Content-Length
-        mock_response.aread.assert_not_called()
-
     @patch("port_ocean.helpers.retry.cast")
     def test_log_response_size_preserves_text_consumption(
         self, mock_cast: Mock
     ) -> None:
-        """Test that _log_response_size preserves response for .text consumption."""
+        """When no Content-Length, no logging/reading; response.text still accessible."""
         mock_transport = Mock()
         mock_logger = Mock()
         mock_cast.return_value = mock_logger
@@ -804,128 +538,12 @@ class TestResponseSizeLoggingIntegration:
         mock_request.method = "GET"
         mock_request.url.host = "api.example.com"
 
-        # Create a mock response with text content
-        text_content = b"Hello, World! This is a test response."
         mock_response = Mock()
-        mock_response.headers = {}  # No Content-Length header to force content reading
-        mock_response.read.return_value = text_content
+        mock_response.headers = {}
         mock_response.text = "Hello, World! This is a test response."
 
-        # Call the logging function
         transport._log_response_size(mock_request, mock_response)
 
-        # Verify logging occurred
-        mock_logger.info.assert_called_once()
-
-        # Verify that response.text can still be accessed
+        mock_logger.info.assert_not_called()
         assert mock_response.text == "Hello, World! This is a test response."
-
-        # Verify that read was called and content was restored
-        mock_response.read.assert_called_once()
-        assert mock_response._content == text_content
-
-    @pytest.mark.asyncio
-    @patch("port_ocean.helpers.retry.cast")
-    async def test_log_response_size_async_preserves_content_consumption(
-        self, mock_cast: Mock
-    ) -> None:
-        """Test that _log_response_size_async preserves response for .content consumption."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.method = "GET"
-        mock_request.url.host = "api.example.com"
-
-        # Create a mock response with binary content
-        binary_content = b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01"
-        mock_response = Mock()
-        mock_response.headers = {}  # No Content-Length header to force content reading
-        mock_response.aread = AsyncMock(return_value=binary_content)
-        mock_response.content = binary_content
-
-        # Call the async logging function
-        await transport._log_response_size_async(mock_request, mock_response)
-
-        # Verify logging occurred
-        mock_logger.info.assert_called_once()
-
-        # Verify that response.content can still be accessed
-        assert mock_response.content == binary_content
-
-        # Verify that aread was called and content was restored
-        mock_response.aread.assert_called_once()
-        assert mock_response._content == binary_content
-
-    @patch("port_ocean.helpers.retry.cast")
-    def test_log_response_size_error_handling_preserves_response(
-        self, mock_cast: Mock
-    ) -> None:
-        """Test that _log_response_size error handling doesn't break response consumption."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.method = "GET"
-        mock_request.url.host = "api.example.com"
-
-        # Create a mock response that will fail on read
-        mock_response = Mock()
-        mock_response.headers = {}  # No Content-Length header to force content reading
-        mock_response.read.side_effect = Exception("Network error")
-        mock_response.json.return_value = {"error": "handled gracefully"}
-
-        # Call the logging function
-        transport._log_response_size(mock_request, mock_response)
-
-        # Verify error was logged
-        mock_logger.error.assert_called_once_with(
-            "Error getting response size: Network error"
-        )
-
-        # Verify that response.json() can still be called despite the error
-        result = mock_response.json()
-        assert result == {"error": "handled gracefully"}
-
-        # Verify that read was attempted
-        mock_response.read.assert_called_once()
-
-    @pytest.mark.asyncio
-    @patch("port_ocean.helpers.retry.cast")
-    async def test_log_response_size_async_error_handling_preserves_response(
-        self, mock_cast: Mock
-    ) -> None:
-        """Test that _log_response_size_async error handling doesn't break response consumption."""
-        mock_transport = Mock()
-        mock_logger = Mock()
-        mock_cast.return_value = mock_logger
-        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
-
-        mock_request = Mock()
-        mock_request.method = "GET"
-        mock_request.url.host = "api.example.com"
-
-        # Create a mock response that will fail on aread
-        mock_response = Mock()
-        mock_response.headers = {}  # No Content-Length header to force content reading
-        mock_response.aread = AsyncMock(side_effect=Exception("Async network error"))
-        mock_response.json.return_value = {"error": "handled gracefully"}
-
-        # Call the async logging function
-        await transport._log_response_size_async(mock_request, mock_response)
-
-        # Verify error was logged
-        mock_logger.error.assert_called_once_with(
-            "Error getting response size: Async network error"
-        )
-
-        # Verify that response.json() can still be called despite the error
-        result = mock_response.json()
-        assert result == {"error": "handled gracefully"}
-
-        # Verify that aread was attempted
-        mock_response.aread.assert_called_once()
+        mock_response.read.assert_not_called()

{port_ocean-0.28.17 → port_ocean-0.28.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "port-ocean"
-version = "0.28.17"
+version = "0.28.19"
 description = "Port Ocean is a CLI tool for managing your Port projects."
 readme = "README.md"
 homepage = "https://app.getport.io"