port-ocean 0.5.9__tar.gz → 0.5.11__tar.gz

{port_ocean-0.5.9 → port_ocean-0.5.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.5.9
+Version: 0.5.11
 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.5.9 → port_ocean-0.5.11}/port_ocean/clients/port/authentication.py

@@ -49,7 +49,9 @@ class PortAuthentication:
 
         credentials = {"clientId": client_id, "clientSecret": client_secret}
         response = await self.client.post(
-            f"{self.api_url}/auth/access_token", json=credentials
+            f"{self.api_url}/auth/access_token",
+            json=credentials,
+            extensions={"retryable": True},
         )
         handle_status_code(response)
         return TokenResponse(**response.json())

{port_ocean-0.5.9 → port_ocean-0.5.11}/port_ocean/clients/port/mixins/entities.py

@@ -133,21 +133,6 @@ class EntityClientMixin:
             return_exceptions=True,
         )
 
-    async def validate_entity_exist(self, identifier: str, blueprint: str) -> None:
-        logger.info(f"Validating entity {identifier} of blueprint {blueprint} exists")
-
-        response = await self.client.get(
-            f"{self.auth.api_url}/blueprints/{blueprint}/entities/{identifier}",
-            headers=await self.auth.headers(),
-        )
-        if response.is_error:
-            logger.error(
-                f"Error validating "
-                f"entity: {identifier} of "
-                f"blueprint: {blueprint}"
-            )
-        handle_status_code(response)
-
     async def search_entities(self, user_agent_type: UserAgentType) -> list[Entity]:
         query = {
             "combinator": "and",
@@ -174,43 +159,8 @@ class EntityClientMixin:
                 "exclude_calculated_properties": "true",
                 "include": ["blueprint", "identifier"],
             },
+            extensions={"retryable": True},
+            timeout=30,
         )
         handle_status_code(response)
         return [Entity.parse_obj(result) for result in response.json()["entities"]]
-
-    async def search_dependent_entities(self, entity: Entity) -> list[Entity]:
-        body = {
-            "combinator": "and",
-            "rules": [
-                {
-                    "operator": "relatedTo",
-                    "blueprint": entity.blueprint,
-                    "value": entity.identifier,
-                    "direction": "downstream",
-                }
-            ],
-        }
-
-        logger.info(f"Searching dependent entity with body {body}")
-        response = await self.client.post(
-            f"{self.auth.api_url}/entities/search",
-            headers=await self.auth.headers(),
-            json=body,
-        )
-        handle_status_code(response)
-
-        return [Entity.parse_obj(result) for result in response.json()["entities"]]
-
-    async def validate_entity_payload(
-        self, entity: Entity, merge: bool, create_missing_related_entities: bool
-    ) -> None:
-        logger.info(f"Validating entity {entity.identifier}")
-        await self.upsert_entity(
-            entity,
-            {
-                "merge": merge,
-                "create_missing_related_entities": create_missing_related_entities,
-                "delete_dependent_entities": False,
-                "validation_only": True,
-            },
-        )

{port_ocean-0.5.9 → port_ocean-0.5.11}/port_ocean/clients/port/retry_transport.py

@@ -15,11 +15,6 @@ class TokenRetryTransport(RetryTransport):
         super().__init__(**kwargs)
         self.port_client = port_client
 
-    def _is_retryable_method(self, request: httpx.Request) -> bool:
-        return super()._is_retryable_method(request) or request.url.path.endswith(
-            "/auth/access_token"
-        )
-
     async def _handle_unauthorized(self, response: httpx.Response) -> None:
         token = await self.port_client.auth.token
         response.headers["Authorization"] = f"Bearer {token}"

{port_ocean-0.5.9 → port_ocean-0.5.11}/port_ocean/config/settings.py

@@ -1,6 +1,7 @@
 from typing import Any, Literal
 
 from pydantic import Extra, AnyHttpUrl, parse_obj_as, validator
+from pydantic.env_settings import InitSettingsSource, EnvSettingsSource, BaseSettings
 from pydantic.fields import Field
 from pydantic.main import BaseModel
 
@@ -10,7 +11,7 @@ from port_ocean.core.event_listener import EventListenerSettingsType
 LogLevelType = Literal["ERROR", "WARNING", "INFO", "DEBUG", "CRITICAL"]
 
 
-class ApplicationSettings(BaseOceanModel):
+class ApplicationSettings(BaseSettings):
     log_level: LogLevelType = "INFO"
     enable_http_logging: bool = True
     port: int = 8000
@@ -21,7 +22,13 @@ class ApplicationSettings(BaseOceanModel):
         env_file_encoding = "utf-8"
 
         @classmethod
-        def customise_sources(cls, init_settings, env_settings, *_, **__):  # type: ignore
+        def customise_sources(  # type: ignore
+            cls,
+            init_settings: InitSettingsSource,
+            env_settings: EnvSettingsSource,
+            *_,
+            **__,
+        ):
             return env_settings, init_settings
 
 

{port_ocean-0.5.9 → port_ocean-0.5.11}/port_ocean/core/handlers/entities_state_applier/port/applier.py

@@ -1,6 +1,3 @@
-import asyncio
-from itertools import chain
-
 from loguru import logger
 
 from port_ocean.clients.port.types import UserAgentType
@@ -14,14 +11,9 @@ from port_ocean.core.handlers.entities_state_applier.port.get_related_entities i
 from port_ocean.core.handlers.entities_state_applier.port.order_by_entities_dependencies import (
     order_by_entities_dependencies,
 )
-from port_ocean.core.handlers.entities_state_applier.port.validate_entity_relations import (
-    validate_entity_relations,
-)
-from port_ocean.core.handlers.entity_processor.base import EntityPortDiff
 from port_ocean.core.models import Entity
 from port_ocean.core.ocean_types import EntityDiff
-from port_ocean.core.utils import is_same_entity, get_unique, get_port_diff
-from port_ocean.exceptions.core import RelationValidationException
+from port_ocean.core.utils import is_same_entity, get_port_diff
 
 
 class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
@@ -32,63 +24,17 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
     through HTTP requests.
     """
 
-    async def _validate_delete_dependent_entities(self, entities: list[Entity]) -> None:
-        logger.info("Validated deleted entities")
-        if not event.port_app_config.delete_dependent_entities:
-            dependent_entities = await asyncio.gather(
-                *(
-                    self.context.port_client.search_dependent_entities(entity)
-                    for entity in entities
-                )
-            )
-            new_dependent_entities = get_unique(
-                [
-                    entity
-                    for entity in chain.from_iterable(dependent_entities)
-                    if not any(is_same_entity(item, entity) for item in entities)
-                ]
-            )
-
-            if new_dependent_entities:
-                raise RelationValidationException(
-                    f"Must enable delete_dependent_entities flag or delete all dependent entities: "
-                    f" {[(dep.blueprint, dep.identifier) for dep in new_dependent_entities]}"
-                )
-
-    async def _validate_entity_diff(self, diff: EntityPortDiff) -> None:
-        config = event.port_app_config
-        await self._validate_delete_dependent_entities(diff.deleted)
-        modified_or_created_entities = diff.modified + diff.created
-
-        if modified_or_created_entities and not config.create_missing_related_entities:
-            logger.info("Validating modified or created entities")
-
-            await asyncio.gather(
-                *(
-                    self.context.port_client.validate_entity_payload(
-                        entity,
-                        config.enable_merge_entity,
-                        create_missing_related_entities=config.create_missing_related_entities,
-                    )
-                    for entity in modified_or_created_entities
-                )
-            )
-
-        if not event.port_app_config.delete_dependent_entities:
-            logger.info("Validating no relation blocks the operation")
-            await validate_entity_relations(diff, self.context.port_client)
-
-    async def _delete_diff(
+    async def _safe_delete(
         self,
         entities_to_delete: list[Entity],
-        created_entities: list[Entity],
+        entities_to_protect: list[Entity],
         user_agent_type: UserAgentType,
     ) -> None:
         if not entities_to_delete:
             return
 
         related_entities = await get_related_entities(
-            created_entities, self.context.port_client
+            entities_to_protect, self.context.port_client
         )
 
         allowed_entities_to_delete = []
@@ -98,7 +44,8 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
                 is_same_entity(entity, entity_to_delete) for entity in related_entities
             )
             is_part_of_created = any(
-                is_same_entity(entity, entity_to_delete) for entity in created_entities
+                is_same_entity(entity, entity_to_delete)
+                for entity in entities_to_protect
             )
             if is_part_of_related:
                 if event.port_app_config.create_missing_related_entities:
@@ -119,21 +66,14 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
         user_agent_type: UserAgentType,
     ) -> None:
         diff = get_port_diff(entities["before"], entities["after"])
+        kept_entities = diff.created + diff.modified
 
         logger.info(
             f"Updating entity diff (created: {len(diff.created)}, deleted: {len(diff.deleted)}, modified: {len(diff.modified)})"
         )
-        await self._validate_entity_diff(diff)
+        await self.upsert(kept_entities, user_agent_type)
 
-        logger.info("Upserting new entities")
-        await self.upsert(diff.created, user_agent_type)
-        logger.info("Upserting modified entities")
-        await self.upsert(diff.modified, user_agent_type)
-
-        logger.info("Deleting diff entities")
-        await self._delete_diff(
-            diff.deleted, diff.created + diff.modified, user_agent_type
-        )
+        await self._safe_delete(diff.deleted, kept_entities, user_agent_type)
 
     async def delete_diff(
         self,
@@ -145,15 +85,13 @@ class HttpEntitiesStateApplier(BaseEntitiesStateApplier):
         if not diff.deleted:
             return
 
+        kept_entities = diff.created + diff.modified
+
         logger.info(
-            f"Updating entity diff (created: {len(diff.created)}, deleted: {len(diff.deleted)}, modified: {len(diff.modified)})"
+            f"Determining entities to delete ({len(diff.deleted)}/{len(kept_entities)})"
         )
-        await self._validate_entity_diff(diff)
 
-        logger.info("Deleting diff entities")
-        await self._delete_diff(
-            diff.deleted, diff.created + diff.modified, user_agent_type
-        )
+        await self._safe_delete(diff.deleted, kept_entities, user_agent_type)
 
     async def upsert(
         self, entities: list[Entity], user_agent_type: UserAgentType

{port_ocean-0.5.9 → port_ocean-0.5.11}/port_ocean/core/integrations/mixins/sync_raw.py

@@ -333,8 +333,6 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
         ):
             app_config = await self.port_app_config_handler.get_port_app_config()
 
-            entities_at_port = await ocean.port_client.search_entities(user_agent_type)
-
             creation_results: list[tuple[list[Entity], list[Exception]]] = []
 
             try:
@@ -369,8 +367,11 @@ class SyncRawMixin(HandlerMixin, EventsMixin):
 
                     logger.error(message, exc_info=error_group)
                 else:
+                    entities_at_port = await ocean.port_client.search_entities(
+                        user_agent_type
+                    )
                     logger.info(
-                        f"Running resync diff calculation, number of entities at Port before resync: {len(entities_at_port)}, number of entities created during sync: {len(flat_created_entities)}"
+                        f"Running resync diff calculation, number of entities found at Port: {len(entities_at_port)}, number of entities found during sync: {len(flat_created_entities)}"
                     )
                     await self.entities_state_applier.delete_diff(
                         {"before": entities_at_port, "after": flat_created_entities},

{port_ocean-0.5.9 → port_ocean-0.5.11}/port_ocean/helpers/retry.py

@@ -179,12 +179,35 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         transport.close()
 
     def _is_retryable_method(self, request: httpx.Request) -> bool:
-        return request.method in self._retryable_methods
+        return request.method in self._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
 
-    def _log_failure(
+    def _log_error(
+        self,
+        request: httpx.Request,
+        error: Exception | None,
+    ) -> None:
+        if not self._logger:
+            return
+
+        if isinstance(error, httpx.ConnectTimeout):
+            self._logger.error(
+                f"Request {request.method} {request.url} failed to connect: {str(error)}"
+            )
+        elif isinstance(error, httpx.TimeoutException):
+            self._logger.error(
+                f"Request {request.method} {request.url} failed with a timeout exception: {str(error)}"
+            )
+        elif isinstance(error, httpx.HTTPError):
+            self._logger.error(
+                f"Request {request.method} {request.url} failed with an HTTP error: {str(error)}"
+            )
+
+    def _log_before_retry(
         self,
         request: httpx.Request,
         sleep_time: float,
@@ -249,7 +272,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         while True:
             if attempts_made > 0:
                 sleep_time = self._calculate_sleep(attempts_made, {})
-                self._log_failure(request, sleep_time, response, error)
+                self._log_before_retry(request, sleep_time, response, error)
                 await asyncio.sleep(sleep_time)
 
             error = None
@@ -262,9 +285,20 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
                 ):
                     return response
                 await response.aclose()
+            except httpx.ConnectTimeout as e:
+                error = e
+                if remaining_attempts < 1:
+                    self._log_error(request, error)
+                    raise
+            except httpx.TimeoutException as e:
+                error = e
+                if remaining_attempts < 1:
+                    self._log_error(request, error)
+                    raise
             except httpx.HTTPError as e:
                 error = e
                 if remaining_attempts < 1:
+                    self._log_error(request, error)
                     raise
             attempts_made += 1
             remaining_attempts -= 1
@@ -281,7 +315,7 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
         while True:
             if attempts_made > 0:
                 sleep_time = self._calculate_sleep(attempts_made, {})
-                self._log_failure(request, sleep_time, response, error)
+                self._log_before_retry(request, sleep_time, response, error)
                 time.sleep(sleep_time)
 
             error = None
@@ -292,9 +326,20 @@ class RetryTransport(httpx.AsyncBaseTransport, httpx.BaseTransport):
                 if remaining_attempts < 1 or not self._should_retry(response):
                     return response
                 response.close()
+            except httpx.ConnectTimeout as e:
+                error = e
+                if remaining_attempts < 1:
+                    self._log_error(request, error)
+                    raise
+            except httpx.TimeoutException as e:
+                error = e
+                if remaining_attempts < 1:
+                    self._log_error(request, error)
+                    raise
             except httpx.HTTPError as e:
                 error = e
                 if remaining_attempts < 1:
+                    self._log_error(request, error)
                     raise
             attempts_made += 1
             remaining_attempts -= 1

{port_ocean-0.5.9 → port_ocean-0.5.11}/pyproject.toml

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

port_ocean-0.5.9/port_ocean/core/handlers/entities_state_applier/port/validate_entity_relations.py

@@ -1,40 +0,0 @@
-import asyncio
-
-from port_ocean.clients.port.client import PortClient
-from port_ocean.core.handlers.entities_state_applier.port.get_related_entities import (
-    get_related_entities,
-)
-from port_ocean.core.handlers.entity_processor.base import EntityPortDiff
-from port_ocean.core.utils import is_same_entity
-from port_ocean.exceptions.core import RelationValidationException
-
-
-async def validate_entity_relations(
-    diff: EntityPortDiff, port_client: PortClient
-) -> None:
-    modified_or_created_entities = diff.modified + diff.created
-    related_entities = await get_related_entities(
-        modified_or_created_entities, port_client
-    )
-
-    required_entities = []
-
-    for entity in related_entities:
-        if any(is_same_entity(item, entity) for item in diff.deleted):
-            raise RelationValidationException(
-                f"Cant delete entity {entity} of blueprint {entity.blueprint} "
-                f"because it was specified as relation target of entity {entity} "
-                f"of blueprint {entity.blueprint}"
-            )
-
-        if not any(
-            is_same_entity(item, entity) for item in modified_or_created_entities
-        ):
-            required_entities.append(entity)
-
-    await asyncio.gather(
-        *(
-            port_client.validate_entity_exist(item.identifier, item.blueprint)
-            for item in required_entities
-        )
-    )