port-ocean 0.18.9__tar.gz → 0.19.1__tar.gz

{port_ocean-0.18.9 → port_ocean-0.19.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.18.9
+Version: 0.19.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.19.1/port_ocean/clients/auth/auth_client.py

@@ -0,0 +1,10 @@
+from abc import ABC, abstractmethod
+
+import httpx
+
+
+class AuthClient(ABC):
+
+    @abstractmethod
+    def refresh_request_auth_creds(self, request: httpx.Request) -> httpx.Request:
+        pass

port_ocean-0.19.1/port_ocean/clients/auth/oauth_client.py

@@ -0,0 +1,22 @@
+from port_ocean.clients.auth.auth_client import AuthClient
+from port_ocean.context.ocean import ocean
+from port_ocean.helpers.retry import register_on_retry_callback
+
+
+class OAuthClient(AuthClient):
+    def __init__(self) -> None:
+        """
+        A client that can refresh a request using an access token.
+        """
+        if self.is_oauth_enabled():
+            register_on_retry_callback(self.refresh_request_auth_creds)
+
+    def is_oauth_enabled(self) -> bool:
+        return ocean.app.load_external_oauth_access_token() is not None
+
+    @property
+    def external_access_token(self) -> str:
+        access_token = ocean.app.load_external_oauth_access_token()
+        if access_token is None:
+            raise ValueError("No external access token found")
+        return access_token

{port_ocean-0.18.9 → port_ocean-0.19.1}/port_ocean/clients/port/mixins/integrations.py

@@ -1,5 +1,5 @@
 import asyncio
-from typing import Any, Dict, TYPE_CHECKING, Optional, TypedDict
+from typing import Any, Dict, List, TYPE_CHECKING, Optional, TypedDict
 from urllib.parse import quote_plus
 
 import httpx
@@ -14,7 +14,7 @@ if TYPE_CHECKING:
 
 
 INTEGRATION_POLLING_INTERVAL_INITIAL_SECONDS = 3
-INTEGRATION_POLLING_INTERVAL_BACKOFF_FACTOR = 1.15
+INTEGRATION_POLLING_INTERVAL_BACKOFF_FACTOR = 1.55
 INTEGRATION_POLLING_RETRY_LIMIT = 30
 CREATE_RESOURCES_PARAM_NAME = "integration_modes"
 CREATE_RESOURCES_PARAM_VALUE = ["create_resources"]
@@ -38,6 +38,27 @@ class IntegrationClientMixin:
         self.client = client
         self._log_attributes: LogAttributes | None = None
 
+    async def is_integration_provision_enabled(
+        self, integration_type: str, should_raise: bool = True, should_log: bool = True
+    ) -> bool:
+        enabled_integrations = await self.get_provision_enabled_integrations(
+            should_raise, should_log
+        )
+        return integration_type in enabled_integrations
+
+    async def get_provision_enabled_integrations(
+        self, should_raise: bool = True, should_log: bool = True
+    ) -> List[str]:
+        logger.info("Fetching provision enabled integrations")
+        response = await self.client.get(
+            f"{self.auth.api_url}/integration/provision-enabled",
+            headers=await self.auth.headers(),
+        )
+
+        handle_status_code(response, should_raise, should_log)
+
+        return response.json().get("integrations", [])
+
     async def _get_current_integration(self) -> httpx.Response:
         logger.info(f"Fetching integration with id: {self.integration_identifier}")
         response = await self.client.get(
@@ -51,7 +72,25 @@ class IntegrationClientMixin:
     ) -> dict[str, Any]:
         response = await self._get_current_integration()
         handle_status_code(response, should_raise, should_log)
-        return response.json().get("integration", {})
+        integration = response.json().get("integration", {})
+        if integration.get("config", None) or not integration:
+            return integration
+        is_provision_enabled_for_integration = integration.get(
+            "installationAppType", None
+        ) and (
+            await self.is_integration_provision_enabled(
+                integration.get("installationAppType", ""),
+                should_raise,
+                should_log,
+            )
+        )
+
+        if is_provision_enabled_for_integration:
+            logger.info(
+                "integration type is enabled, polling until provisioning is complete"
+            )
+            return self._poll_integration_until_default_provisioning_is_complete()
+        return integration
 
     async def get_log_attributes(self) -> LogAttributes:
         if self._log_attributes is None:
@@ -72,7 +111,7 @@ class IntegrationClientMixin:
             )
             response = await self._get_current_integration()
             integration_json = response.json()
-            if integration_json.get("integration", {}).get("config", {}):
+            if integration_json.get("integration", {}).get("config", {}) != {}:
                 return integration_json
 
             logger.info(

{port_ocean-0.18.9 → port_ocean-0.19.1}/port_ocean/config/settings.py

@@ -1,12 +1,12 @@
 from typing import Any, Literal, Type, cast
 
-from pydantic import Extra, AnyHttpUrl, parse_obj_as, parse_raw_as
+from pydantic import AnyHttpUrl, Extra, parse_obj_as, parse_raw_as
 from pydantic.class_validators import root_validator, validator
-from pydantic.env_settings import InitSettingsSource, EnvSettingsSource, BaseSettings
+from pydantic.env_settings import BaseSettings, EnvSettingsSource, InitSettingsSource
 from pydantic.fields import Field
 from pydantic.main import BaseModel
 
-from port_ocean.config.base import BaseOceanSettings, BaseOceanModel
+from port_ocean.config.base import BaseOceanModel, BaseOceanSettings
 from port_ocean.core.event_listener import EventListenerSettingsType
 from port_ocean.core.models import CreatePortResourcesOrigin, Runtime
 from port_ocean.utils.misc import get_integration_name, get_spec_file
@@ -71,6 +71,7 @@ class IntegrationConfiguration(BaseOceanSettings, extra=Extra.allow):
     # Determines if Port should generate resources such as blueprints and pages instead of ocean
     create_port_resources_origin: CreatePortResourcesOrigin | None = None
     send_raw_data_examples: bool = True
+    oauth_access_token_file_path: str | None = None
     port: PortSettings
     event_listener: EventListenerSettingsType = Field(
         default=cast(EventListenerSettingsType, {"type": "POLLING"})

{port_ocean-0.18.9 → port_ocean-0.19.1}/port_ocean/core/defaults/initialize.py

@@ -75,7 +75,7 @@ async def _initialize_required_integration_settings(
                 create_port_resources_origin_in_port=integration_config.create_port_resources_origin
                 == CreatePortResourcesOrigin.Port,
             )
-        elif not integration.get("config"):
+        elif not integration.get("config", None):
             logger.info(
                 "Encountered that the integration's mapping is empty, Initializing to default mapping"
             )
@@ -213,11 +213,20 @@ async def _initialize_defaults(
         config_class, integration_config.resources_path
     )
 
+    is_integration_provision_enabled = (
+        await port_client.is_integration_provision_enabled(
+            integration_config.integration.type
+        )
+    )
+
     if (
         not integration_config.create_port_resources_origin
-        and integration_config.runtime.is_saas_runtime
+        and is_integration_provision_enabled
     ):
-        logger.info("Setting resources origin to be Port")
+        # Need to set default since spec is missing
+        logger.info(
+            f"Setting resources origin to be Port (integration {integration_config.integration.type} is supported)"
+        )
         integration_config.create_port_resources_origin = CreatePortResourcesOrigin.Port
 
     if (
@@ -228,7 +237,10 @@ async def _initialize_defaults(
             "Resources origin is set to be Port, verifying integration is supported"
         )
         org_feature_flags = await port_client.get_organization_feature_flags()
-        if ORG_USE_PROVISIONED_DEFAULTS_FEATURE_FLAG not in org_feature_flags:
+        if (
+            not is_integration_provision_enabled
+            or ORG_USE_PROVISIONED_DEFAULTS_FEATURE_FLAG not in org_feature_flags
+        ):
             logger.info(
                 "Port origin for Integration is not supported, changing resources origin to use Ocean"
             )

{port_ocean-0.18.9 → port_ocean-0.19.1}/port_ocean/helpers/retry.py

@@ -9,6 +9,15 @@ from typing import Any, Callable, Coroutine, Iterable, Mapping, Union
 import httpx
 from dateutil.parser import isoparse
 
+_ON_RETRY_CALLBACK: Callable[[httpx.Request], httpx.Request] | None = None
+
+
+def register_on_retry_callback(
+    _on_retry_callback: Callable[[httpx.Request], httpx.Request]
+) -> None:
+    global _ON_RETRY_CALLBACK
+    _ON_RETRY_CALLBACK = _on_retry_callback
+
 
 # Adapted from https://github.com/encode/httpx/issues/108#issuecomment-1434439481
 class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
@@ -43,7 +52,6 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         _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.
-
     """
 
     RETRYABLE_METHODS = frozenset(["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"])
@@ -53,6 +61,8 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
             HTTPStatus.BAD_GATEWAY,
             HTTPStatus.SERVICE_UNAVAILABLE,
             HTTPStatus.GATEWAY_TIMEOUT,
+            HTTPStatus.UNAUTHORIZED,
+            HTTPStatus.BAD_REQUEST,
         ]
     )
     MAX_BACKOFF_WAIT_IN_SECONDS = 60
@@ -316,6 +326,8 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
                 if remaining_attempts < 1:
                     self._log_error(request, error)
                     raise
+            if _ON_RETRY_CALLBACK:
+                request = _ON_RETRY_CALLBACK(request)
             attempts_made += 1
             remaining_attempts -= 1
 
@@ -357,5 +369,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
                 if remaining_attempts < 1:
                     self._log_error(request, error)
                     raise
+            if _ON_RETRY_CALLBACK:
+                request = _ON_RETRY_CALLBACK(request)
             attempts_made += 1
             remaining_attempts -= 1

{port_ocean-0.18.9 → port_ocean-0.19.1}/port_ocean/ocean.py

@@ -1,31 +1,31 @@
 import asyncio
 import sys
-import threading
 from contextlib import asynccontextmanager
-from typing import Callable, Any, Dict, AsyncIterator, Type
+import threading
+from typing import Any, AsyncIterator, Callable, Dict, Type
 
-from fastapi import FastAPI, APIRouter
+from fastapi import APIRouter, FastAPI
 from loguru import logger
 from pydantic import BaseModel
-from starlette.types import Scope, Receive, Send
+from starlette.types import Receive, Scope, Send
 
-from port_ocean.core.handlers.resync_state_updater import ResyncStateUpdater
 from port_ocean.clients.port.client import PortClient
 from port_ocean.config.settings import (
     IntegrationConfiguration,
 )
 from port_ocean.context.ocean import (
     PortOceanContext,
-    ocean,
     initialize_port_ocean_context,
+    ocean,
 )
+from port_ocean.core.handlers.resync_state_updater import ResyncStateUpdater
 from port_ocean.core.integrations.base import BaseIntegration
 from port_ocean.log.sensetive import sensitive_log_filter
 from port_ocean.middlewares import request_handler
+from port_ocean.utils.misc import IntegrationStateStatus
 from port_ocean.utils.repeat import repeat_every
 from port_ocean.utils.signal import signal_handler
 from port_ocean.version import __integration_version__
-from port_ocean.utils.misc import IntegrationStateStatus
 from port_ocean.core.handlers.webhook.processor_manager import WebhookProcessorManager
 
 
@@ -118,6 +118,18 @@ class Ocean:
             )
             await repeated_function()
 
+    def load_external_oauth_access_token(self) -> str | None:
+        if self.config.oauth_access_token_file_path is not None:
+            try:
+                with open(self.config.oauth_access_token_file_path, "r") as f:
+                    return f.read()
+            except Exception:
+                logger.exception(
+                    "Failed to load external oauth access token from file",
+                    file_path=self.config.oauth_access_token_file_path,
+                )
+        return None
+
     def initialize_app(self) -> None:
         self.fast_api_app.include_router(self.integration_router, prefix="/integration")
 

port_ocean-0.19.1/port_ocean/tests/clients/oauth/test_oauth_client.py

@@ -0,0 +1,96 @@
+import pytest
+import httpx
+from unittest.mock import MagicMock, patch
+from port_ocean.ocean import Ocean
+
+from port_ocean.clients.auth.oauth_client import OAuthClient
+from port_ocean.config.settings import IntegrationConfiguration
+
+
+@pytest.fixture
+def mock_ocean() -> Ocean:
+    with patch("port_ocean.ocean.Ocean.__init__", return_value=None):
+        ocean_mock = Ocean()
+        ocean_mock.config = MagicMock(spec=IntegrationConfiguration)
+        return ocean_mock
+
+
+class MockOAuthClient(OAuthClient):
+    def __init__(self, is_oauth_enabled_value: bool = True):
+        self._is_oauth_enabled = is_oauth_enabled_value
+        self._access_token = "mock_access_token"
+        super().__init__()
+
+    def is_oauth_enabled(self) -> bool:
+        return self._is_oauth_enabled
+
+    def refresh_request_auth_creds(self, request: httpx.Request) -> httpx.Request:
+        headers = dict(request.headers)
+        headers["Authorization"] = f"Bearer {self.access_token}"
+        return httpx.Request(
+            method=request.method,
+            url=request.url,
+            headers=headers,
+            content=request.content,
+        )
+
+    @property
+    def access_token(self) -> str:
+        return self._access_token
+
+
+@pytest.fixture
+def mock_oauth_client() -> MockOAuthClient:
+    return MockOAuthClient()
+
+
+@pytest.fixture
+def disabled_oauth_client() -> MockOAuthClient:
+    return MockOAuthClient(is_oauth_enabled_value=False)
+
+
+def test_oauth_client_initialization(mock_oauth_client: MockOAuthClient) -> None:
+    assert isinstance(mock_oauth_client, OAuthClient)
+    assert mock_oauth_client.is_oauth_enabled() is True
+
+
+def test_oauth_client_disabled_initialization(
+    disabled_oauth_client: MockOAuthClient,
+) -> None:
+    assert isinstance(disabled_oauth_client, OAuthClient)
+    assert disabled_oauth_client.is_oauth_enabled() is False
+
+
+def test_refresh_request_auth_creds(mock_oauth_client: MockOAuthClient) -> None:
+    # Create request with some content and existing headers
+    original_headers = {"Accept": "application/json", "X-Custom": "value"}
+    original_content = b'{"key": "value"}'
+    original_request = httpx.Request(
+        "GET",
+        "https://api.example.com",
+        headers=original_headers,
+        content=original_content,
+    )
+
+    refreshed_request = mock_oauth_client.refresh_request_auth_creds(original_request)
+
+    # Verify all attributes are identical except headers
+    assert refreshed_request.method == original_request.method
+    assert refreshed_request.url == original_request.url
+    assert refreshed_request.content == original_request.content
+
+    # Verify headers: should contain all original headers plus the new Authorization
+    for key, value in original_headers.items():
+        assert refreshed_request.headers[key] == value
+    assert refreshed_request.headers["Authorization"] == "Bearer mock_access_token"
+    # New headers should be:
+    # {'host': 'api.example.com',
+    #  'accept': 'application/json',
+    #  'x-custom': 'value',
+    #  'content-length': '16',
+    #  'authorization': '[secure]'}
+    assert len(refreshed_request.headers) == 5
+
+
+def test_access_token_property(mock_oauth_client: MockOAuthClient) -> None:
+    assert mock_oauth_client.access_token == "mock_access_token"

port_ocean-0.19.1/port_ocean/tests/test_ocean.py

@@ -0,0 +1,49 @@
+import pytest
+from unittest.mock import MagicMock, mock_open, patch
+from port_ocean.ocean import Ocean
+from port_ocean.config.settings import IntegrationConfiguration
+
+
+@pytest.fixture
+def mock_ocean() -> Ocean:
+    with patch("port_ocean.ocean.Ocean.__init__", return_value=None):
+        ocean_mock = Ocean()
+        ocean_mock.config = MagicMock(spec=IntegrationConfiguration)
+        return ocean_mock
+
+
+def test_load_external_oauth_access_token_no_file(mock_ocean: Ocean) -> None:
+    # Setup
+    mock_ocean.config.oauth_access_token_file_path = None
+
+    # Execute
+    result = mock_ocean.load_external_oauth_access_token()
+
+    # Assert
+    assert result is None
+
+
+def test_load_external_oauth_access_token_with_file(mock_ocean: Ocean) -> None:
+    # Setup
+    mock_ocean.config.oauth_access_token_file_path = "/path/to/token.txt"
+    mock_file_content = "test_access_token"
+
+    with patch("builtins.open", mock_open(read_data=mock_file_content)):
+        # Execute
+        result = mock_ocean.load_external_oauth_access_token()
+
+        # Assert
+        assert result == "test_access_token"
+
+
+def test_load_external_oauth_access_token_with_empty_file(mock_ocean: Ocean) -> None:
+    # Setup
+    mock_ocean.config.oauth_access_token_file_path = "/path/to/token.txt"
+    mock_file_content = ""
+
+    with patch("builtins.open", mock_open(read_data=mock_file_content)):
+        # Execute
+        result = mock_ocean.load_external_oauth_access_token()
+
+        # Assert
+        assert result == ""

{port_ocean-0.18.9 → port_ocean-0.19.1}/port_ocean/utils/async_http.py

@@ -18,7 +18,7 @@ def _get_http_client_context() -> httpx.AsyncClient:
 
 
 """
-Utilize this client for all outbound integration requests to the third-party application. It functions as a wrapper 
+Utilize this client for all outbound integration requests to the third-party application. It functions as a wrapper
 around the httpx.AsyncClient, incorporating retry logic at the transport layer for handling retries on 5xx errors and
 connection errors.
 

{port_ocean-0.18.9 → port_ocean-0.19.1}/port_ocean/utils/repeat.py

@@ -22,10 +22,8 @@ def repeat_every(
 ) -> NoArgsNoReturnDecorator:
     """
     This function returns a decorator that modifies a function so it is periodically re-executed after its first call.
-
     The function it decorates should accept no arguments and return nothing. If necessary, this can be accomplished
     by using `functools.partial` or otherwise wrapping the target function prior to decoration.
-
     Parameters
     ----------
     seconds: float

{port_ocean-0.18.9 → port_ocean-0.19.1}/pyproject.toml

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