port-ocean 0.27.10__py3-none-any.whl → 0.28.1__py3-none-any.whl

port_ocean/core/integrations/mixins/sync_raw.py

@@ -455,16 +455,16 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
             ],
             value=number_of_transformed_entities,
         )
-
-        ocean.metrics.inc_metric(
-            name=MetricType.OBJECT_COUNT_NAME,
-            labels=[
-                ocean.metrics.current_resource_kind(),
-                MetricPhase.TRANSFORM,
-                MetricPhase.TransformResult.FILTERED_OUT,
-            ],
-            value=number_of_raw_results - number_of_transformed_entities,
-        )
+        if number_of_raw_results > number_of_transformed_entities :
+            ocean.metrics.inc_metric(
+                name=MetricType.OBJECT_COUNT_NAME,
+                labels=[
+                    ocean.metrics.current_resource_kind(),
+                    MetricPhase.TRANSFORM,
+                    MetricPhase.TransformResult.FILTERED_OUT,
+                ],
+                value=number_of_raw_results - number_of_transformed_entities,
+            )
 
         return passed_entities, errors
 

port_ocean/helpers/async_client.py

@@ -3,7 +3,7 @@ from typing import Any, Type
 import httpx
 from loguru import logger
 
-from port_ocean.helpers.retry import RetryTransport
+from port_ocean.helpers.retry import RetryTransport, RetryConfig
 from port_ocean.helpers.stream import Stream
 
 
@@ -18,10 +18,12 @@ class OceanAsyncClient(httpx.AsyncClient):
         self,
         transport_class: Type[RetryTransport] = RetryTransport,
         transport_kwargs: dict[str, Any] | None = None,
+        retry_config: RetryConfig | None = None,
         **kwargs: Any,
     ):
         self._transport_kwargs = transport_kwargs
         self._transport_class = transport_class
+        self._retry_config = retry_config
         super().__init__(**kwargs)
 
     def _init_transport(  # type: ignore[override]
@@ -33,9 +35,8 @@ class OceanAsyncClient(httpx.AsyncClient):
             return super()._init_transport(transport=transport, **kwargs)
 
         return self._transport_class(
-            wrapped_transport=httpx.AsyncHTTPTransport(
-                **kwargs,
-            ),
+            wrapped_transport=httpx.AsyncHTTPTransport(**kwargs),
+            retry_config=self._retry_config,
             logger=logger,
             **(self._transport_kwargs or {}),
         )
@@ -44,10 +45,8 @@ class OceanAsyncClient(httpx.AsyncClient):
         self, proxy: httpx.Proxy, **kwargs: Any
     ) -> httpx.AsyncBaseTransport:
         return self._transport_class(
-            wrapped_transport=httpx.AsyncHTTPTransport(
-                proxy=proxy,
-                **kwargs,
-            ),
+            wrapped_transport=httpx.AsyncHTTPTransport(proxy=proxy, **kwargs),
+            retry_config=self._retry_config,
             logger=logger,
             **(self._transport_kwargs or {}),
         )

port_ocean/helpers/retry.py

@@ -4,12 +4,24 @@ import time
 from datetime import datetime
 from functools import partial
 from http import HTTPStatus
-from typing import Any, Callable, Coroutine, Iterable, Mapping, Union, cast
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Iterable,
+    Mapping,
+    Union,
+    cast,
+    Optional,
+    List,
+)
 import httpx
 from dateutil.parser import isoparse
 import logging
 
+MAX_BACKOFF_WAIT_IN_SECONDS = 60
 _ON_RETRY_CALLBACK: Callable[[httpx.Request], httpx.Request] | None = None
+_RETRY_CONFIG_CALLBACK: Callable[[], "RetryConfig"] | None = None
 
 
 def register_on_retry_callback(
@@ -19,6 +31,92 @@ def register_on_retry_callback(
     _ON_RETRY_CALLBACK = _on_retry_callback
 
 
+def register_retry_config_callback(
+    retry_config_callback: Callable[[], "RetryConfig"]
+) -> None:
+    """Register a callback function that returns a RetryConfig instance.
+
+    The callback will be called when a RetryTransport needs to be created.
+
+    Args:
+        retry_config_callback: A function that returns a RetryConfig instance
+    """
+    global _RETRY_CONFIG_CALLBACK
+    _RETRY_CONFIG_CALLBACK = retry_config_callback
+
+
+class RetryConfig:
+    """Configuration class for retry behavior that can be customized per integration."""
+
+    def __init__(
+        self,
+        max_attempts: int = 10,
+        max_backoff_wait: float = MAX_BACKOFF_WAIT_IN_SECONDS,
+        base_delay: float = 0.1,
+        jitter_ratio: float = 0.1,
+        respect_retry_after_header: bool = True,
+        retryable_methods: Optional[Iterable[str]] = None,
+        retry_status_codes: Optional[Iterable[int]] = None,
+        retry_after_headers: Optional[List[str]] = None,
+        additional_retry_status_codes: Optional[Iterable[int]] = None,
+    ):
+        """
+        Initialize retry configuration.
+
+        Args:
+            max_attempts: Maximum number of retry attempts
+            max_backoff_wait: Maximum backoff wait time in seconds
+            base_delay: Base delay for exponential backoff
+            jitter_ratio: Jitter ratio for backoff (0-0.5)
+            respect_retry_after_header: Whether to respect Retry-After header
+            retryable_methods: HTTP methods that can be retried (overrides defaults if provided)
+            retry_status_codes: DEPRECATED - use additional_retry_status_codes instead
+            retry_after_headers: Custom headers to check for retry timing (e.g., ['X-RateLimit-Reset', 'Retry-After'])
+            additional_retry_status_codes: Additional status codes to retry (extends system defaults)
+        """
+        self.max_attempts = max_attempts
+        self.max_backoff_wait = max_backoff_wait
+        self.base_delay = base_delay
+        self.jitter_ratio = jitter_ratio
+        self.respect_retry_after_header = respect_retry_after_header
+
+        # Default retryable methods - always include these unless explicitly overridden
+        default_methods = frozenset(
+            ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"]
+        )
+        self.retryable_methods = (
+            frozenset(retryable_methods) if retryable_methods else default_methods
+        )
+
+        # Default retry status codes - always include these for system reliability
+        default_status_codes = frozenset(
+            [
+                HTTPStatus.TOO_MANY_REQUESTS,
+                HTTPStatus.BAD_GATEWAY,
+                HTTPStatus.SERVICE_UNAVAILABLE,
+                HTTPStatus.GATEWAY_TIMEOUT,
+                HTTPStatus.UNAUTHORIZED,
+                HTTPStatus.BAD_REQUEST,
+            ]
+        )
+
+        # Additional status codes to retry (extends defaults)
+        additional_codes = (
+            frozenset(additional_retry_status_codes)
+            if additional_retry_status_codes
+            else frozenset()
+        )
+
+        # Combine defaults with additional codes for extensibility
+        self.retry_status_codes = default_status_codes | additional_codes
+        self.retry_after_headers = retry_after_headers or ["Retry-After"]
+
+        if jitter_ratio < 0 or jitter_ratio > 0.5:
+            raise ValueError(
+                f"Jitter ratio should be between 0 and 0.5, actual {jitter_ratio}"
+            )
+
+
 # Adapted from https://github.com/encode/httpx/issues/108#issuecomment-1434439481
 class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
     """
@@ -41,32 +139,16 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"].
         retry_status_codes (Iterable[int], optional): The HTTP status codes that can be retried. Defaults to
             [429, 502, 503, 504].
+        retry_config (RetryConfig, optional): Configuration for retry behavior. If not provided, uses defaults.
+        logger (Any, optional): The logger to use for logging retries.
 
     Attributes:
         _wrapped_transport (Union[httpx.BaseTransport, httpx.AsyncBaseTransport]): The underlying HTTP transport
             being wrapped.
-        _max_attempts (int): The maximum number of times to retry a request.
-        _backoff_factor (float): The factor by which the wait time increases with each retry attempt.
-        _respect_retry_after_header (bool): Whether to respect the Retry-After header in HTTP responses.
-        _retryable_methods (frozenset): The HTTP methods that can be retried.
-        _retry_status_codes (frozenset): The HTTP status codes that can be retried.
-        _jitter_ratio (float): The amount of jitter to add to the backoff time.
-        _max_backoff_wait (float): The maximum time to wait between retries in seconds.
+        _retry_config (RetryConfig): The retry configuration object.
+        _logger (Any): The logger to use for logging retries.
     """
 
-    RETRYABLE_METHODS = frozenset(["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"])
-    RETRYABLE_STATUS_CODES = frozenset(
-        [
-            HTTPStatus.TOO_MANY_REQUESTS,
-            HTTPStatus.BAD_GATEWAY,
-            HTTPStatus.SERVICE_UNAVAILABLE,
-            HTTPStatus.GATEWAY_TIMEOUT,
-            HTTPStatus.UNAUTHORIZED,
-            HTTPStatus.BAD_REQUEST,
-        ]
-    )
-    MAX_BACKOFF_WAIT_IN_SECONDS = 60
-
     def __init__(
         self,
         wrapped_transport: Union[httpx.BaseTransport, httpx.AsyncBaseTransport],
@@ -77,6 +159,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         respect_retry_after_header: bool = True,
         retryable_methods: Iterable[str] | None = None,
         retry_status_codes: Iterable[int] | None = None,
+        retry_config: Optional[RetryConfig] = None,
         logger: Any | None = None,
     ) -> None:
         """
@@ -106,29 +189,27 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             retry_status_codes (Iterable[int], optional):
                 The HTTP status codes that can be retried.
                 Defaults to [429, 502, 503, 504].
+            retry_config (RetryConfig, optional):
+                Configuration for retry behavior. If not provided, uses default configuration.
             logger (Any): The logger to use for logging retries.
         """
         self._wrapped_transport = wrapped_transport
-        if jitter_ratio < 0 or jitter_ratio > 0.5:
-            raise ValueError(
-                f"Jitter ratio should be between 0 and 0.5, actual {jitter_ratio}"
+
+        if retry_config is not None:
+            self._retry_config = retry_config
+        elif _RETRY_CONFIG_CALLBACK is not None:
+            self._retry_config = _RETRY_CONFIG_CALLBACK()
+        else:
+            self._retry_config = RetryConfig(
+                max_attempts=max_attempts,
+                max_backoff_wait=max_backoff_wait,
+                base_delay=base_delay,
+                jitter_ratio=jitter_ratio,
+                respect_retry_after_header=respect_retry_after_header,
+                retryable_methods=retryable_methods,
+                retry_status_codes=retry_status_codes,
             )
 
-        self._max_attempts = max_attempts
-        self._base_delay = base_delay
-        self._respect_retry_after_header = respect_retry_after_header
-        self._retryable_methods = (
-            frozenset(retryable_methods)
-            if retryable_methods
-            else self.RETRYABLE_METHODS
-        )
-        self._retry_status_codes = (
-            frozenset(retry_status_codes)
-            if retry_status_codes
-            else self.RETRYABLE_STATUS_CODES
-        )
-        self._jitter_ratio = jitter_ratio
-        self._max_backoff_wait = max_backoff_wait
         self._logger = logger
 
     def handle_request(self, request: httpx.Request) -> httpx.Response:
@@ -206,12 +287,13 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         transport.close()
 
     def _is_retryable_method(self, request: httpx.Request) -> bool:
-        return request.method in self._retryable_methods or request.extensions.get(
-            "retryable", False
+        return (
+            request.method in self._retry_config.retryable_methods
+            or request.extensions.get("retryable", False)
         )
 
     def _should_retry(self, response: httpx.Response) -> bool:
-        return response.status_code in self._retry_status_codes
+        return response.status_code in self._retry_config.retry_status_codes
 
     def _log_error(
         self,
@@ -314,46 +396,54 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         )
 
     async def _should_retry_async(self, response: httpx.Response) -> bool:
-        return response.status_code in self._retry_status_codes
+        return response.status_code in self._retry_config.retry_status_codes
 
     def _calculate_sleep(
         self, attempts_made: int, headers: Union[httpx.Headers, Mapping[str, str]]
     ) -> float:
-        # Retry-After
-        # The Retry-After response HTTP header indicates how long the user agent should wait before
-        # making a follow-up request. There are three main cases this header is used:
-        # - When sent with a 503 (Service Unavailable) response, this indicates how long the service
-        #   is expected to be unavailable.
-        # - When sent with a 429 (Too Many Requests) response, this indicates how long to wait before
-        #   making a new request.
-        # - When sent with a redirect response, such as 301 (Moved Permanently), this indicates the
-        #   minimum time that the user agent is asked to wait before issuing the redirected request.
-        retry_after_header = (headers.get("Retry-After") or "").strip()
-        if self._respect_retry_after_header and retry_after_header:
-            if retry_after_header.isdigit():
-                return float(retry_after_header)
-
-            try:
-                parsed_date = isoparse(
-                    retry_after_header
-                ).astimezone()  # converts to local time
-                diff = (parsed_date - datetime.now().astimezone()).total_seconds()
-                if diff > 0:
-                    return min(diff, self._max_backoff_wait)
-            except ValueError:
-                pass
-
-        backoff = self._base_delay * (2 ** (attempts_made - 1))
-        jitter = (backoff * self._jitter_ratio) * random.choice([1, -1])
+        # Check custom retry headers first, then fall back to Retry-After
+        if self._retry_config.respect_retry_after_header:
+            for header_name in self._retry_config.retry_after_headers:
+                if header_value := (headers.get(header_name) or "").strip():
+                    sleep_time = self._parse_retry_header(header_value)
+                    if sleep_time is not None:
+                        return min(sleep_time, self._retry_config.max_backoff_wait)
+
+        # Fall back to exponential backoff
+        backoff = self._retry_config.base_delay * (2 ** (attempts_made - 1))
+        jitter = (backoff * self._retry_config.jitter_ratio) * random.choice([1, -1])
         total_backoff = backoff + jitter
-        return min(total_backoff, self._max_backoff_wait)
+        return min(total_backoff, self._retry_config.max_backoff_wait)
+
+    def _parse_retry_header(self, header_value: str) -> Optional[float]:
+        """Parse retry header value and return sleep time in seconds.
+
+        Args:
+            header_value: The header value to parse (e.g., "30", "2023-12-01T12:00:00Z")
+
+        Returns:
+            Sleep time in seconds if parsing succeeds, None if the header value cannot be parsed
+        """
+        if header_value.isdigit():
+            return float(header_value)
+
+        try:
+            # Try to parse as ISO date (common for rate limit headers like X-RateLimit-Reset)
+            parsed_date = isoparse(header_value).astimezone()
+            diff = (parsed_date - datetime.now().astimezone()).total_seconds()
+            if diff > 0:
+                return diff
+        except ValueError:
+            pass
+
+        return None
 
     async def _retry_operation_async(
         self,
         request: httpx.Request,
         send_method: Callable[..., Coroutine[Any, Any, httpx.Response]],
     ) -> httpx.Response:
-        remaining_attempts = self._max_attempts
+        remaining_attempts = self._retry_config.max_attempts
         attempts_made = 0
         response: httpx.Response | None = None
         error: Exception | None = None
@@ -403,7 +493,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         request: httpx.Request,
         send_method: Callable[..., httpx.Response],
     ) -> httpx.Response:
-        remaining_attempts = self._max_attempts
+        remaining_attempts = self._retry_config.max_attempts
         attempts_made = 0
         response: httpx.Response | None = None
         error: Exception | None = None

port_ocean/tests/helpers/test_retry.py

@@ -0,0 +1,309 @@
+import pytest
+from unittest.mock import Mock
+from http import HTTPStatus
+import httpx
+
+from port_ocean.helpers.retry import (
+    RetryConfig,
+    RetryTransport,
+    register_retry_config_callback,
+    register_on_retry_callback,
+)
+import port_ocean.helpers.retry as retry_module
+
+
+class TestRetryConfig:
+    def test_default_configuration(self) -> None:
+        """Test RetryConfig with default parameters."""
+        config = RetryConfig()
+
+        assert config.max_attempts == 10
+        assert config.max_backoff_wait == 60.0
+        assert config.base_delay == 0.1
+        assert config.jitter_ratio == 0.1
+        assert config.respect_retry_after_header is True
+        assert config.retryable_methods == frozenset(
+            ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"]
+        )
+        assert config.retry_status_codes == frozenset(
+            [
+                HTTPStatus.TOO_MANY_REQUESTS,
+                HTTPStatus.BAD_GATEWAY,
+                HTTPStatus.SERVICE_UNAVAILABLE,
+                HTTPStatus.GATEWAY_TIMEOUT,
+                HTTPStatus.UNAUTHORIZED,
+                HTTPStatus.BAD_REQUEST,
+            ]
+        )
+        assert config.retry_after_headers == ["Retry-After"]
+
+    def test_custom_configuration(self) -> None:
+        """Test RetryConfig with custom parameters."""
+        config = RetryConfig(
+            max_attempts=5,
+            max_backoff_wait=30.0,
+            base_delay=2.0,
+            jitter_ratio=0.2,
+            respect_retry_after_header=False,
+            retryable_methods=["GET", "POST"],
+            retry_after_headers=["X-Custom-Retry", "Retry-After"],
+            additional_retry_status_codes=[418, 420],
+        )
+
+        assert config.max_attempts == 5
+        assert config.max_backoff_wait == 30.0
+        assert config.base_delay == 2.0
+        assert config.jitter_ratio == 0.2
+        assert config.respect_retry_after_header is False
+        assert config.retryable_methods == frozenset(["GET", "POST"])
+        # Should include defaults + additional codes
+        expected_codes = frozenset(
+            [
+                HTTPStatus.TOO_MANY_REQUESTS,
+                HTTPStatus.BAD_GATEWAY,
+                HTTPStatus.SERVICE_UNAVAILABLE,
+                HTTPStatus.GATEWAY_TIMEOUT,
+                HTTPStatus.UNAUTHORIZED,
+                HTTPStatus.BAD_REQUEST,
+                418,
+                420,
+            ]
+        )
+        assert config.retry_status_codes == expected_codes
+        assert config.retry_after_headers == ["X-Custom-Retry", "Retry-After"]
+
+    def test_additional_status_codes(self) -> None:
+        """Test that additional status codes extend defaults."""
+        config = RetryConfig(
+            additional_retry_status_codes=[418, 420],
+        )
+
+        # Should include defaults + additional codes
+        expected_codes = frozenset(
+            [
+                HTTPStatus.TOO_MANY_REQUESTS,
+                HTTPStatus.BAD_GATEWAY,
+                HTTPStatus.SERVICE_UNAVAILABLE,
+                HTTPStatus.GATEWAY_TIMEOUT,
+                HTTPStatus.UNAUTHORIZED,
+                HTTPStatus.BAD_REQUEST,
+                418,
+                420,
+            ]
+        )
+        assert config.retry_status_codes == expected_codes
+
+    def test_invalid_jitter_ratio(self) -> None:
+        """Test that invalid jitter ratio raises ValueError."""
+        with pytest.raises(
+            ValueError, match="Jitter ratio should be between 0 and 0.5"
+        ):
+            RetryConfig(jitter_ratio=0.6)
+
+        with pytest.raises(
+            ValueError, match="Jitter ratio should be between 0 and 0.5"
+        ):
+            RetryConfig(jitter_ratio=-0.1)
+
+    def test_empty_additional_status_codes(self) -> None:
+        """Test that empty additional status codes work correctly."""
+        config = RetryConfig(additional_retry_status_codes=[])
+        assert config.retry_status_codes == frozenset(
+            [
+                HTTPStatus.TOO_MANY_REQUESTS,
+                HTTPStatus.BAD_GATEWAY,
+                HTTPStatus.SERVICE_UNAVAILABLE,
+                HTTPStatus.GATEWAY_TIMEOUT,
+                HTTPStatus.UNAUTHORIZED,
+                HTTPStatus.BAD_REQUEST,
+            ]
+        )
+
+
+class TestRetryConfigCallback:
+    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_register_retry_config_callback(self) -> None:
+        """Test registering a retry config callback."""
+
+        def mock_callback() -> RetryConfig:
+            return RetryConfig(max_attempts=5)
+
+        register_retry_config_callback(mock_callback)
+
+        assert retry_module._RETRY_CONFIG_CALLBACK is mock_callback
+        config = retry_module._RETRY_CONFIG_CALLBACK()
+        assert config.max_attempts == 5
+
+    def test_register_on_retry_callback(self) -> None:
+        """Test registering an on retry callback."""
+
+        def mock_callback(request: httpx.Request) -> httpx.Request:
+            return request
+
+        register_on_retry_callback(mock_callback)
+
+        assert retry_module._ON_RETRY_CALLBACK is mock_callback
+
+    def test_callback_overwrite(self) -> None:
+        """Test that registering a new callback overwrites the previous one."""
+
+        def callback1() -> RetryConfig:
+            return RetryConfig(max_attempts=1)
+
+        def callback2() -> RetryConfig:
+            return RetryConfig(max_attempts=2)
+
+        register_retry_config_callback(callback1)
+        assert retry_module._RETRY_CONFIG_CALLBACK is not None
+        assert retry_module._RETRY_CONFIG_CALLBACK().max_attempts == 1
+
+        register_retry_config_callback(callback2)
+        assert retry_module._RETRY_CONFIG_CALLBACK is not None
+        assert retry_module._RETRY_CONFIG_CALLBACK().max_attempts == 2
+
+
+class TestRetryTransport:
+    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_retry_transport_with_direct_config(self) -> None:
+        """Test RetryTransport with direct retry_config parameter."""
+        mock_transport = Mock()
+        config = RetryConfig(max_attempts=5)
+
+        transport = RetryTransport(
+            wrapped_transport=mock_transport,
+            retry_config=config,
+        )
+
+        assert transport._retry_config is config
+        assert transport._retry_config.max_attempts == 5
+
+    def test_retry_transport_with_callback(self) -> None:
+        """Test RetryTransport using registered callback."""
+
+        def mock_callback() -> RetryConfig:
+            return RetryConfig(max_attempts=7)
+
+        register_retry_config_callback(mock_callback)
+
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        assert transport._retry_config.max_attempts == 7
+
+    def test_retry_transport_priority_order(self) -> None:
+        """Test that direct config takes priority over callback."""
+
+        def mock_callback() -> RetryConfig:
+            return RetryConfig(max_attempts=7)
+
+        register_retry_config_callback(mock_callback)
+
+        mock_transport = Mock()
+        direct_config = RetryConfig(max_attempts=5)
+
+        transport = RetryTransport(
+            wrapped_transport=mock_transport,
+            retry_config=direct_config,
+        )
+
+        assert transport._retry_config.max_attempts == 5  # Direct config wins
+
+    def test_retry_transport_default_config(self) -> None:
+        """Test RetryTransport with no config or callback."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        assert transport._retry_config.max_attempts == 10  # Default value
+        assert transport._retry_config.retry_after_headers == ["Retry-After"]
+
+    def test_is_retryable_method(self) -> None:
+        """Test _is_retryable_method functionality."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        # Test with default retryable methods
+        mock_request = Mock()
+        mock_request.method = "GET"
+        mock_request.extensions = {}
+
+        assert transport._is_retryable_method(mock_request) is True
+
+        mock_request.method = "POST"
+        assert transport._is_retryable_method(mock_request) is False
+
+        # Test with retryable extension
+        mock_request.extensions = {"retryable": True}
+        assert transport._is_retryable_method(mock_request) is True
+
+    def test_should_retry(self) -> None:
+        """Test _should_retry functionality."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        mock_response = Mock()
+        mock_response.status_code = 429
+        assert transport._should_retry(mock_response) is True
+
+        mock_response.status_code = 200
+        assert transport._should_retry(mock_response) is False
+
+    def test_parse_retry_header(self) -> None:
+        """Test _parse_retry_header functionality."""
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        # Test numeric seconds
+        assert transport._parse_retry_header("30") == 30.0
+
+        # Test invalid numeric
+        assert transport._parse_retry_header("invalid") is None
+
+        # Test ISO date (would need proper date parsing test)
+        # This is a basic test - actual date parsing would need more complex setup
+        assert (
+            transport._parse_retry_header("2023-12-01T12:00:00Z") is None
+        )  # Will fail parsing
+
+
+class TestRetryConfigIntegration:
+    """Integration tests for retry configuration."""
+
+    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_integration_style_config(self) -> None:
+        """Test configuration similar to GitHub integration."""
+
+        def integration_retry_config() -> RetryConfig:
+            return RetryConfig(
+                max_attempts=10,
+                max_backoff_wait=60.0,
+                base_delay=1.0,
+                jitter_ratio=0.1,
+                respect_retry_after_header=True,
+                retry_after_headers=["X-RateLimit-Reset", "Retry-After"],
+                additional_retry_status_codes=[HTTPStatus.FORBIDDEN],
+            )
+
+        register_retry_config_callback(integration_retry_config)
+
+        mock_transport = Mock()
+        transport = RetryTransport(wrapped_transport=mock_transport)
+
+        assert transport._retry_config.max_attempts == 10
+        assert transport._retry_config.base_delay == 1.0
+        assert transport._retry_config.retry_after_headers == [
+            "X-RateLimit-Reset",
+            "Retry-After",
+        ]
+        assert HTTPStatus.FORBIDDEN in transport._retry_config.retry_status_codes

{port_ocean-0.27.10.dist-info → port_ocean-0.28.1.dist-info}/METADATA

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

@@ -123,7 +123,7 @@ port_ocean/core/integrations/mixins/events.py,sha256=2L7P3Jhp8XBqddh2_o9Cn4N261n
 port_ocean/core/integrations/mixins/handler.py,sha256=mZ7-0UlG3LcrwJttFbMe-R4xcOU2H_g33tZar7PwTv8,3771
 port_ocean/core/integrations/mixins/live_events.py,sha256=zM24dhNc7uHx9XYZ6toVhDADPA90EnpOmZxgDegFZbA,4196
 port_ocean/core/integrations/mixins/sync.py,sha256=Vm_898pLKBwfVewtwouDWsXoxcOLicnAy6pzyqqk6U8,4053
-port_ocean/core/integrations/mixins/sync_raw.py,sha256=50tklPFBYvVoucIcCx1yYU-gwzliXCOX7kJP6_dgsNI,40631
+port_ocean/core/integrations/mixins/sync_raw.py,sha256=EJLF0vMFVkQi4zJPQAFtg-VkQJsOGbya3yhEfWu2L1c,40734
 port_ocean/core/integrations/mixins/utils.py,sha256=ytnFX7Lyv6N3CgBnOXxYaI1cRDq5Z4NDrVFiwE6bn-M,5250
 port_ocean/core/models.py,sha256=DNbKpStMINI2lIekKprTqBevqkw_wFuFayN19w1aDfQ,2893
 port_ocean/core/ocean_types.py,sha256=bkLlTd8XfJK6_JDl0eXUHfE_NygqgiInSMwJ4YJH01Q,1399
@@ -140,10 +140,10 @@ port_ocean/exceptions/port_defaults.py,sha256=2a7Koy541KxMan33mU-gbauUxsumG3NT4i
 port_ocean/exceptions/utils.py,sha256=gjOqpi-HpY1l4WlMFsGA9yzhxDhajhoGGdDDyGbLnqI,197
 port_ocean/exceptions/webhook_processor.py,sha256=4SnkVzVwiacH_Ip4qs1hRHa6GanhnojW_TLTdQQtm7Y,363
 port_ocean/helpers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-port_ocean/helpers/async_client.py,sha256=LOgUlZ5Cs_WUSc8XujCVjPGvzZ_3AuFJNKPy0FKV3fA,1987
+port_ocean/helpers/async_client.py,sha256=M8gKUjX8ZwRbmJ-U6KNq-p-nfGr0CwHdS0eN_pbZAJ0,2103
 port_ocean/helpers/metric/metric.py,sha256=-dw7-Eqr65AZwv0M-xPaAk98g_JS16ICBc9_UkycFbE,14543
 port_ocean/helpers/metric/utils.py,sha256=1lAgrxnZLuR_wUNDyPOPzLrm32b8cDdioob2lvnPQ1A,1619
-port_ocean/helpers/retry.py,sha256=VHAp6j9-Vid6aNR5sca3S0aW6b1S2oYw9vT9hi1N22U,18556
+port_ocean/helpers/retry.py,sha256=QM04mzaevIUlg8HnHjeY9UT_D4k26BHx3hVkCjV_jnY,21675
 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
@@ -190,6 +190,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/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
@@ -207,8 +208,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.27.10.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
-port_ocean-0.27.10.dist-info/METADATA,sha256=Igj6QUVBOykcFVAw94SzlNlVos1FrGhIAINmZnLK1GM,7016
-port_ocean-0.27.10.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-port_ocean-0.27.10.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
-port_ocean-0.27.10.dist-info/RECORD,,
+port_ocean-0.28.1.dist-info/LICENSE.md,sha256=WNHhf_5RCaeuKWyq_K39vmp9F28LxKsB4SpomwSZ2L0,11357
+port_ocean-0.28.1.dist-info/METADATA,sha256=PSPEzll-3f7zXAELk1jUxqAlzwsxtxLksle9ITyREwg,7015
+port_ocean-0.28.1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+port_ocean-0.28.1.dist-info/entry_points.txt,sha256=F_DNUmGZU2Kme-8NsWM5LLE8piGMafYZygRYhOVtcjA,54
+port_ocean-0.28.1.dist-info/RECORD,,