port-ocean 0.28.16__py3-none-any.whl → 0.28.17__py3-none-any.whl

port_ocean/helpers/retry.py

@@ -359,8 +359,11 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         else:
             # If no Content-Length header, try to get actual content size
             try:
-                actual_size = len(await response.aread())
+                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}"
@@ -383,8 +386,11 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         else:
             # If no Content-Length header, try to get actual content size
             try:
-                actual_size = len(response.read())
+                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}"

port_ocean/tests/helpers/test_retry.py

@@ -1,5 +1,5 @@
 import pytest
-from unittest.mock import Mock
+from unittest.mock import Mock, AsyncMock, patch
 from http import HTTPStatus
 import httpx
 
@@ -307,3 +307,625 @@ class TestRetryConfigIntegration:
             "Retry-After",
         ]
         assert HTTPStatus.FORBIDDEN in transport._retry_config.retry_status_codes
+
+
+class TestResponseSizeLogging:
+    """Tests for response size logging functionality."""
+
+    def setup_method(self) -> None:
+        """Reset global callback state before each test."""
+        retry_module._RETRY_CONFIG_CALLBACK = None
+        retry_module._ON_RETRY_CALLBACK = None
+
+    def test_should_log_response_size_with_logger(self) -> None:
+        """Test _should_log_response_size returns True when logger is present and not getport.io."""
+        mock_transport = Mock()
+        mock_logger = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
+
+        mock_request = Mock()
+        mock_request.url.host = "api.example.com"
+
+        assert transport._should_log_response_size(mock_request) is True
+
+    def test_should_log_response_size_without_logger(self) -> None:
+        """Test _should_log_response_size returns False when no logger."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        mock_request = Mock()
+        mock_request.url.host = "api.example.com"
+
+        assert transport._should_log_response_size(mock_request) is False
+
+    def test_should_log_response_size_getport_io(self) -> None:
+        """Test _should_log_response_size returns False for getport.io domains."""
+        mock_transport = Mock()
+        mock_logger = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport, logger=mock_logger)
+
+        mock_request = Mock()
+        mock_request.url.host = "api.getport.io"
+
+        assert transport._should_log_response_size(mock_request) is False
+
+    def test_get_content_length_from_headers(self) -> None:
+        """Test _get_content_length extracts content length from headers."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        mock_response = Mock()
+        mock_response.headers = {"Content-Length": "1024"}
+
+        assert transport._get_content_length(mock_response) == 1024
+
+    def test_get_content_length_case_insensitive(self) -> None:
+        """Test _get_content_length works with case insensitive headers."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        mock_response = Mock()
+        mock_response.headers = {"content-length": "2048"}
+
+        assert transport._get_content_length(mock_response) == 2048
+
+    def test_get_content_length_no_header(self) -> None:
+        """Test _get_content_length returns None when no content-length header."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        mock_response = Mock()
+        mock_response.headers = {}
+
+        assert transport._get_content_length(mock_response) is None
+
+    def test_get_content_length_invalid_value(self) -> None:
+        """Test _get_content_length handles invalid header values."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        mock_response = Mock()
+        mock_response.headers = {"Content-Length": "invalid"}
+
+        # Should raise ValueError when converting to int
+        with pytest.raises(ValueError):
+            transport._get_content_length(mock_response)
+
+    @patch("port_ocean.helpers.retry.cast")
+    def test_log_response_size_with_content_length(self, mock_cast: Mock) -> None:
+        """Test _log_response_size 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"}
+
+        transport._log_response_size(mock_request, mock_response)
+
+        mock_logger.info.assert_called_once_with(
+            "Response for GET https://api.example.com/data - Size: 1024 bytes"
+        )
+
+    @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."""
+        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.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_logger.info.assert_not_called()
+
+    @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."""
+        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"}
+
+        transport._log_response_size(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_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."""
+
+    def setup_method(self) -> None:
+        """Reset global callback state before each test."""
+        retry_module._RETRY_CONFIG_CALLBACK = None
+        retry_module._ON_RETRY_CALLBACK = None
+
+    @patch("port_ocean.helpers.retry.cast")
+    def test_log_response_size_preserves_json_consumption(
+        self, mock_cast: Mock
+    ) -> None:
+        """Test that _log_response_size 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'{"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.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
+        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
+
+    @patch("port_ocean.helpers.retry.cast")
+    def test_log_response_size_with_content_length_preserves_json(
+        self, mock_cast: Mock
+    ) -> None:
+        """Test that _log_response_size 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 = "POST"
+        mock_request.url.host = "api.example.com"
+
+        # Create a mock response with Content-Length header
+        mock_response = Mock()
+        mock_response.headers = {"Content-Length": "1024"}
+        mock_response.json.return_value = {"status": "success", "id": 123}
+
+        # 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
+        result = mock_response.json()
+        assert result == {"status": "success", "id": 123}
+
+        # 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."""
+        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 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.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
+        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()

{port_ocean-0.28.16.dist-info → port_ocean-0.28.17.dist-info}/METADATA

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

@@ -144,7 +144,7 @@ port_ocean/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 port_ocean/helpers/async_client.py,sha256=M8gKUjX8ZwRbmJ-U6KNq-p-nfGr0CwHdS0eN_pbZAJ0,2103
 port_ocean/helpers/metric/metric.py,sha256=6SMxov1WcZAV0NehMGMqWiLoOIpw-2fOpVbtPWhmW1c,14544
 port_ocean/helpers/metric/utils.py,sha256=1lAgrxnZLuR_wUNDyPOPzLrm32b8cDdioob2lvnPQ1A,1619
-port_ocean/helpers/retry.py,sha256=QM04mzaevIUlg8HnHjeY9UT_D4k26BHx3hVkCjV_jnY,21675
+port_ocean/helpers/retry.py,sha256=fkKL_dSNKbGLpa9qi3Ceu2yCqcnzC0OV3dcEWo_kPHA,22067
 port_ocean/helpers/stream.py,sha256=_UwsThzXynxWzL8OlBT1pmb2evZBi9HaaqeAGNuTuOI,2338
 port_ocean/log/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 port_ocean/log/handlers.py,sha256=LJ1WAfq7wYCrBpeLPihMKmWjdSahKKXNHFMRYkbk0Co,3630
@@ -193,7 +193,7 @@ port_ocean/tests/helpers/integration.py,sha256=_RxS-RHpu11lrbhUXYPZp862HLWx8AoD7
 port_ocean/tests/helpers/ocean_app.py,sha256=N06vcNI1klqdcNFq-PXL5vm77u-hODsOSXnj9p8d1AI,2249
 port_ocean/tests/helpers/port_client.py,sha256=S0CXvZWUoHFWWQUOEgdkDammK9Fs3R06wx0flaMrTsg,647
 port_ocean/tests/helpers/smoke_test.py,sha256=_9aJJFRfuGJEg2D2YQJVJRmpreS6gEPHHQq8Q01x4aQ,2697
-port_ocean/tests/helpers/test_retry.py,sha256=c4kS5XrQNv8r-uqPLbWVGvudTy3b_dHxhcCjm7ZWeAQ,11033
+port_ocean/tests/helpers/test_retry.py,sha256=4wuacabVZTGOICCd0dHlVklhLytsCGu2zjo8hnqEeEs,35912
 port_ocean/tests/log/test_handlers.py,sha256=x2P2Hd6Cb3sQafIE3TRGltbbHeiFHaiEjwRn9py_03g,2165
 port_ocean/tests/test_metric.py,sha256=gDdeJcqJDQ_o3VrYrW23iZyw2NuUsyATdrygSXhcDuQ,8096
 port_ocean/tests/test_ocean.py,sha256=bsXKGTVEjwLSbR7-qSmI4GZ-EzDo0eBE3TNSMsWzYxM,1502
@@ -211,8 +211,8 @@ port_ocean/utils/repeat.py,sha256=U2OeCkHPWXmRTVoPV-VcJRlQhcYqPWI5NfmPlb1JIbc,32
 port_ocean/utils/signal.py,sha256=J1sI-e_32VHP_VUa5bskLMFoJjJOAk5isrnewKDikUI,2125
 port_ocean/utils/time.py,sha256=pufAOH5ZQI7gXvOvJoQXZXZJV-Dqktoj9Qp9eiRwmJ4,1939
 port_ocean/version.py,sha256=UsuJdvdQlazzKGD3Hd5-U7N69STh8Dq9ggJzQFnu9fU,177
-port_ocean-0.28.16.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.28.16.dist-info/METADATA,sha256=F6ugYDYHUDQt0YMZ8cghhxj4skE6nM8c7hBrf5GCqZE,7016
-port_ocean-0.28.16.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.28.16.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.28.16.dist-info/RECORD,,
+port_ocean-0.28.17.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.28.17.dist-info/METADATA,sha256=rHk9ILkvieFzWeeX1dljjZ0wfjN9EPX9NDl5tLwOFDc,7016
+port_ocean-0.28.17.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.28.17.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.28.17.dist-info/RECORD,,