port-ocean 0.4.3__tar.gz → 0.4.4__tar.gz

{port_ocean-0.4.3 → port_ocean-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.4.3
+Version: 0.4.4
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port

{port_ocean-0.4.3 → port_ocean-0.4.4}/port_ocean/clients/port/authentication.py

@@ -42,7 +42,7 @@ class PortAuthentication:
         self.integration_identifier = integration_identifier
         self.integration_type = integration_type
         self.integration_version = integration_version
-        self._last_token_object: TokenResponse | None = None
+        self.last_token_object: TokenResponse | None = None
 
     async def _get_token(self, client_id: str, client_secret: str) -> TokenResponse:
         logger.info(f"Fetching access token for clientId: {client_id}")
@@ -71,13 +71,13 @@ class PortAuthentication:
 
     @property
     async def token(self) -> str:
-        if not self._last_token_object or self._last_token_object.expired:
+        if not self.last_token_object or self.last_token_object.expired:
             msg = "Token expired, fetching new token"
-            if not self._last_token_object:
+            if not self.last_token_object:
                 msg = "No token found, fetching new token"
             logger.info(msg)
-            self._last_token_object = await self._get_token(
+            self.last_token_object = await self._get_token(
                 self.client_id, self.client_secret
             )
 
-        return self._last_token_object.full_token
+        return self.last_token_object.full_token

{port_ocean-0.4.3 → port_ocean-0.4.4}/port_ocean/clients/port/client.py

@@ -10,8 +10,7 @@ from port_ocean.clients.port.types import (
 )
 from port_ocean.clients.port.utils import (
     handle_status_code,
-    async_client,
-    retry_on_http_status,
+    get_internal_http_client,
 )
 from port_ocean.exceptions.clients import KafkaCredentialsNotFound
 
@@ -32,7 +31,7 @@ class PortClient(
         integration_version: str,
     ):
         self.api_url = f"{base_url}/v1"
-        self.client = async_client
+        self.client = get_internal_http_client(self)
         self.auth = PortAuthentication(
             self.client,
             client_id,
@@ -49,7 +48,6 @@ class PortClient(
         BlueprintClientMixin.__init__(self, self.auth, self.client)
         MigrationClientMixin.__init__(self, self.auth, self.client)
 
-    @retry_on_http_status(status_code=401)
     async def get_kafka_creds(self) -> KafkaCreds:
         logger.info("Fetching organization kafka credentials")
         response = await self.client.get(
@@ -66,7 +64,6 @@ class PortClient(
 
         return credentials
 
-    @retry_on_http_status(status_code=401)
     async def get_org_id(self) -> str:
         logger.info("Fetching organization id")
 

{port_ocean-0.4.3 → port_ocean-0.4.4}/port_ocean/clients/port/mixins/blueprints.py

@@ -5,7 +5,7 @@ from loguru import logger
 
 from port_ocean.clients.port.authentication import PortAuthentication
 from port_ocean.clients.port.types import UserAgentType
-from port_ocean.clients.port.utils import handle_status_code, retry_on_http_status
+from port_ocean.clients.port.utils import handle_status_code
 from port_ocean.core.models import Blueprint
 
 
@@ -14,7 +14,6 @@ class BlueprintClientMixin:
         self.auth = auth
         self.client = client
 
-    @retry_on_http_status(status_code=401)
     async def get_blueprint(self, identifier: str) -> Blueprint:
         logger.info(f"Fetching blueprint with id: {identifier}")
         response = await self.client.get(
@@ -24,7 +23,6 @@ class BlueprintClientMixin:
         handle_status_code(response)
         return Blueprint.parse_obj(response.json()["blueprint"])
 
-    @retry_on_http_status(status_code=401)
     async def create_blueprint(
         self,
         raw_blueprint: dict[str, Any],
@@ -39,7 +37,6 @@ class BlueprintClientMixin:
         if response.is_success:
             return response.json()["blueprint"]
 
-    @retry_on_http_status(status_code=401)
     async def patch_blueprint(
         self,
         identifier: str,
@@ -55,7 +52,6 @@ class BlueprintClientMixin:
         )
         handle_status_code(response)
 
-    @retry_on_http_status(status_code=401)
     async def delete_blueprint(
         self,
         identifier: str,
@@ -85,7 +81,6 @@ class BlueprintClientMixin:
             handle_status_code(response, should_raise)
             return response.json().get("migrationId", "")
 
-    @retry_on_http_status(status_code=401)
     async def create_action(
         self, blueprint_identifier: str, action: dict[str, Any]
     ) -> None:
@@ -98,7 +93,6 @@ class BlueprintClientMixin:
 
         handle_status_code(response)
 
-    @retry_on_http_status(status_code=401)
     async def create_scorecard(
         self,
         blueprint_identifier: str,

{port_ocean-0.4.3 → port_ocean-0.4.4}/port_ocean/clients/port/mixins/entities.py

@@ -5,7 +5,7 @@ from loguru import logger
 
 from port_ocean.clients.port.authentication import PortAuthentication
 from port_ocean.clients.port.types import RequestOptions, UserAgentType
-from port_ocean.clients.port.utils import handle_status_code, retry_on_http_status
+from port_ocean.clients.port.utils import handle_status_code
 from port_ocean.core.models import Entity
 
 
@@ -14,7 +14,6 @@ class EntityClientMixin:
         self.auth = auth
         self.client = client
 
-    @retry_on_http_status(status_code=401)
     async def upsert_entity(
         self,
         entity: Entity,
@@ -50,7 +49,6 @@ class EntityClientMixin:
             )
         handle_status_code(response, should_raise)
 
-    @retry_on_http_status(status_code=401)
     async def delete_entity(
         self,
         entity: Entity,
@@ -80,7 +78,6 @@ class EntityClientMixin:
 
         handle_status_code(response, should_raise)
 
-    @retry_on_http_status(status_code=401)
     async def validate_entity_exist(self, identifier: str, blueprint: str) -> None:
         logger.info(f"Validating entity {identifier} of blueprint {blueprint} exists")
 
@@ -96,7 +93,6 @@ class EntityClientMixin:
             )
         handle_status_code(response)
 
-    @retry_on_http_status(status_code=401)
     async def search_entities(self, user_agent_type: UserAgentType) -> list[Entity]:
         query = {
             "combinator": "and",
@@ -122,7 +118,6 @@ class EntityClientMixin:
         handle_status_code(response)
         return [Entity.parse_obj(result) for result in response.json()["entities"]]
 
-    @retry_on_http_status(status_code=401)
     async def search_dependent_entities(self, entity: Entity) -> list[Entity]:
         body = {
             "combinator": "and",
@@ -146,7 +141,6 @@ class EntityClientMixin:
 
         return [Entity.parse_obj(result) for result in response.json()["entities"]]
 
-    @retry_on_http_status(status_code=401)
     async def validate_entity_payload(
         self, entity: Entity, options: RequestOptions
     ) -> None:

{port_ocean-0.4.3 → port_ocean-0.4.4}/port_ocean/clients/port/mixins/integrations.py

@@ -5,7 +5,7 @@ from loguru import logger
 from starlette import status
 
 from port_ocean.clients.port.authentication import PortAuthentication
-from port_ocean.clients.port.utils import handle_status_code, retry_on_http_status
+from port_ocean.clients.port.utils import handle_status_code
 
 if TYPE_CHECKING:
     from port_ocean.core.handlers.port_app_config.models import PortAppConfig
@@ -32,7 +32,6 @@ class IntegrationClientMixin:
         )
         return response
 
-    @retry_on_http_status(status_code=401)
     async def get_current_integration(
         self, should_raise: bool = True, should_log: bool = True
     ) -> dict[str, Any]:
@@ -40,7 +39,6 @@ class IntegrationClientMixin:
         handle_status_code(response, should_raise, should_log)
         return response.json()["integration"]
 
-    @retry_on_http_status(status_code=401)
     async def create_integration(
         self,
         _type: str,
@@ -63,7 +61,6 @@ class IntegrationClientMixin:
         )
         handle_status_code(response)
 
-    @retry_on_http_status(status_code=401)
     async def patch_integration(
         self,
         _type: str | None = None,
@@ -88,7 +85,6 @@ class IntegrationClientMixin:
         )
         handle_status_code(response)
 
-    @retry_on_http_status(status_code=401)
     async def initialize_integration(
         self,
         _type: str,

port_ocean-0.4.4/port_ocean/clients/port/retry_transport.py

@@ -0,0 +1,51 @@
+import asyncio
+from http import HTTPStatus
+from typing import TYPE_CHECKING, Any
+
+import httpx
+
+from port_ocean.helpers.retry import RetryTransport
+
+if TYPE_CHECKING:
+    from port_ocean.clients.port.client import PortClient
+
+
+class TokenRetryTransport(RetryTransport):
+    def __init__(self, port_client: "PortClient", *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        self.port_client = port_client
+
+    async def _handle_unauthorized(self, response: httpx.Response) -> None:
+        token = await self.port_client.auth.token
+        response.headers["Authorization"] = f"Bearer {token}"
+
+    def is_token_error(self, response: httpx.Response) -> bool:
+        return (
+            response.status_code == HTTPStatus.UNAUTHORIZED
+            and "/auth/access_token" not in str(response.request.url)
+            and self.port_client.auth.last_token_object is not None
+            and self.port_client.auth.last_token_object.expired
+        )
+
+    async def _should_retry_async(self, response: httpx.Response) -> bool:
+        if self.is_token_error(response):
+            if self._logger:
+                self._logger.info(
+                    "Got unauthorized response, trying to refresh token before retrying"
+                )
+            await self._handle_unauthorized(response)
+            return True
+        return await super()._should_retry_async(response)
+
+    def _should_retry(self, response: httpx.Response) -> bool:
+        if self.is_token_error(response):
+            if self._logger:
+                self._logger.info(
+                    "Got unauthorized response, trying to refresh token before retrying"
+                )
+            asyncio.get_running_loop().run_until_complete(
+                self._handle_unauthorized(response)
+            )
+
+            return True
+        return super()._should_retry(response)

port_ocean-0.4.4/port_ocean/clients/port/utils.py

@@ -0,0 +1,51 @@
+from typing import TYPE_CHECKING
+
+import httpx
+from loguru import logger
+from werkzeug.local import LocalStack, LocalProxy
+
+from port_ocean.clients.port.retry_transport import TokenRetryTransport
+
+if TYPE_CHECKING:
+    from port_ocean.clients.port.client import PortClient
+
+_http_client: LocalStack[httpx.AsyncClient] = LocalStack()
+
+
+def _get_http_client_context(port_client: "PortClient") -> httpx.AsyncClient:
+    client = _http_client.top
+    if client is None:
+        client = httpx.AsyncClient(
+            transport=TokenRetryTransport(
+                port_client,
+                httpx.AsyncHTTPTransport(),
+                logger=logger,
+            )
+        )
+        _http_client.push(client)
+
+    return client
+
+
+_port_internal_async_client: httpx.AsyncClient = None  # type: ignore
+
+
+def get_internal_http_client(port_client: "PortClient") -> httpx.AsyncClient:
+    global _port_internal_async_client
+    if _port_internal_async_client is None:
+        _port_internal_async_client = LocalProxy(
+            lambda: _get_http_client_context(port_client)
+        )
+
+    return _port_internal_async_client
+
+
+def handle_status_code(
+    response: httpx.Response, should_raise: bool = True, should_log: bool = True
+) -> None:
+    if should_log and response.is_error:
+        logger.error(
+            f"Request failed with status code: {response.status_code}, Error: {response.text}"
+        )
+    if should_raise:
+        response.raise_for_status()

{port_ocean-0.4.3 → port_ocean-0.4.4}/port_ocean/core/handlers/entities_state_applier/port/order_by_entities_dependencies.py

@@ -1,7 +1,8 @@
-from graphlib import TopologicalSorter
+from graphlib import TopologicalSorter, CycleError
 from typing import Set
 
 from port_ocean.core.models import Entity
+from port_ocean.exceptions.core import OceanAbortException
 
 Node = tuple[str, str]
 
@@ -35,4 +36,11 @@ def order_by_entities_dependencies(entities: list[Entity]) -> list[Entity]:
             nodes[node(entity)].add(node(related_entity))
 
     sort_op = TopologicalSorter(nodes)
-    return [entities_map[item] for item in sort_op.static_order()]
+    try:
+        return [entities_map[item] for item in sort_op.static_order()]
+    except CycleError as ex:
+        raise OceanAbortException(
+            "Cannot order entities due to cyclic dependencies. \n"
+            "If you do want to have cyclic dependencies, please make sure to set the keys"
+            " 'createMissingRelatedEntities' and 'deleteDependentEntities' in the integration config in Port."
+        ) from ex

{port_ocean-0.4.3 → port_ocean-0.4.4}/port_ocean/helpers/retry.py

@@ -178,6 +178,12 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         transport: httpx.BaseTransport = self._wrapped_transport  # type: ignore
         transport.close()
 
+    def _should_retry(self, response: httpx.Response) -> bool:
+        return response.status_code in self._retry_status_codes
+
+    async def _should_retry_async(self, response: httpx.Response) -> bool:
+        return response.status_code in self._retry_status_codes
+
     def _calculate_sleep(
         self, attempts_made: int, headers: Union[httpx.Headers, Mapping[str, str]]
     ) -> float:
@@ -228,10 +234,8 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
                     )
                 await asyncio.sleep(sleep_time)
             response = await send_method(request)
-            if (
-                remaining_attempts < 1
-                or response.status_code not in self._retry_status_codes
-            ):
+            response.request = request
+            if remaining_attempts < 1 or not (await self._should_retry_async(response)):
                 return response
             await response.aclose()
             attempts_made += 1
@@ -255,10 +259,8 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
                     )
                 time.sleep(sleep_time)
             response = send_method(request)
-            if (
-                remaining_attempts < 1
-                or response.status_code not in self._retry_status_codes
-            ):
+            response.request = request
+            if remaining_attempts < 1 or not self._should_retry(response):
                 return response
             response.close()
             attempts_made += 1

{port_ocean-0.4.3 → port_ocean-0.4.4}/port_ocean/utils.py

@@ -3,17 +3,49 @@ import inspect
 from asyncio import ensure_future
 from functools import wraps
 from importlib.util import module_from_spec, spec_from_file_location
-from pathlib import Path
 from time import time
 from traceback import format_exception
 from types import ModuleType
 from typing import Callable, Any, Coroutine
 from uuid import uuid4
 
+import httpx
 import tomli
 import yaml
 from loguru import logger
+from pathlib import Path
 from starlette.concurrency import run_in_threadpool
+from werkzeug.local import LocalStack, LocalProxy
+
+from port_ocean.helpers.retry import RetryTransport
+
+_http_client: LocalStack[httpx.AsyncClient] = LocalStack()
+
+
+def _get_http_client_context() -> httpx.AsyncClient:
+    client = _http_client.top
+    if client is None:
+        client = httpx.AsyncClient(
+            transport=RetryTransport(
+                httpx.AsyncHTTPTransport(),
+                logger=logger,
+            )
+        )
+        _http_client.push(client)
+
+    return client
+
+
+"""
+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.
+
+The client is instantiated lazily, only coming into existence upon its initial access. It should not be closed when in
+use, as it operates as a singleton shared across all events in the thread. It also takes care of recreating the client
+in scenarios such as the creation of a new event loop, such as when initiating a new thread.
+"""
+http_async_client: httpx.AsyncClient = LocalProxy(lambda: _get_http_client_context())  # type: ignore
 
 
 def get_time(seconds_precision: bool = True) -> float:

{port_ocean-0.4.3 → port_ocean-0.4.4}/pyproject.toml

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

port_ocean-0.4.3/port_ocean/clients/port/utils.py

@@ -1,79 +0,0 @@
-from functools import wraps
-from typing import Callable, Any
-
-import httpx
-from loguru import logger
-from werkzeug.local import LocalStack, LocalProxy
-
-from port_ocean.helpers.retry import RetryTransport
-
-_http_client: LocalStack[httpx.AsyncClient] = LocalStack()
-
-
-def _get_http_client_context() -> httpx.AsyncClient:
-    client = _http_client.top
-    if client is None:
-        client = httpx.AsyncClient(
-            transport=RetryTransport(
-                httpx.AsyncHTTPTransport(),
-                logger=logger,
-            )
-        )
-        _http_client.push(client)
-
-    return client
-
-
-async_client: httpx.AsyncClient = LocalProxy(lambda: _get_http_client_context())  # type: ignore
-
-
-def handle_status_code(
-    response: httpx.Response, should_raise: bool = True, should_log: bool = True
-) -> None:
-    if should_log and response.is_error:
-        logger.error(
-            f"Request failed with status code: {response.status_code}, Error: {response.text}"
-        )
-    if should_raise:
-        response.raise_for_status()
-
-
-def retry_on_http_status(
-    status_code: int,
-    max_retries: int = 2,
-    verbose: bool = True,
-) -> Callable[..., Callable[..., Any]]:
-    """
-    Decorator to retry a function if it raises a httpx.HTTPStatusError with a given status code
-    :param status_code: The status code to retry on
-    :param max_retries: The maximum number of retries
-    :param verbose: Whether to log retries
-    """
-
-    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
-        @wraps(func)
-        async def wrapper(*args, **kwargs) -> Any:  # type: ignore
-            retries = 0
-            while retries < max_retries:
-                try:
-                    result = await func(*args, **kwargs)
-                    return result
-                except httpx.HTTPStatusError as err:
-                    if err.response.status_code == status_code:
-                        retries += 1
-                        if retries < max_retries:
-                            if verbose:
-                                logger.warning(
-                                    f"Retrying {func.__name__} after {status_code} error. Retry {retries}/{max_retries}"
-                                )
-                        else:
-                            logger.error(
-                                f"Reached max retries {max_retries} for {func.__name__} after {status_code} error"
-                            )
-                            raise
-                    else:
-                        raise
-
-        return wrapper
-
-    return decorator