port-ocean 0.21.5__py3-none-any.whl → 0.22.1__py3-none-any.whl

port_ocean/tests/core/handlers/entities_state_applier/test_applier.py

@@ -6,6 +6,11 @@ from port_ocean.core.handlers.entities_state_applier.port.applier import (
 from port_ocean.core.models import Entity
 from port_ocean.core.ocean_types import EntityDiff
 from port_ocean.clients.port.types import UserAgentType
+from port_ocean.ocean import Ocean
+from port_ocean.context.ocean import PortOceanContext
+from port_ocean.tests.core.conftest import create_entity
+from port_ocean.core.handlers.port_app_config.models import PortAppConfig
+from port_ocean.context.event import event_context, EventType
 
 
 @pytest.mark.asyncio
@@ -23,8 +28,8 @@ async def test_delete_diff_no_deleted_entities() -> None:
 
 
 @pytest.mark.asyncio
-async def test_delete_diff_below_threshold() -> None:
-    applier = HttpEntitiesStateApplier(Mock())
+async def test_delete_diff_below_threshold(mock_context: PortOceanContext) -> None:
+    applier = HttpEntitiesStateApplier(mock_context)
     entities = EntityDiff(
         before=[
             Entity(identifier="1", blueprint="test"),
@@ -48,8 +53,10 @@ async def test_delete_diff_below_threshold() -> None:
 
 
 @pytest.mark.asyncio
-async def test_delete_diff_above_default_threshold() -> None:
-    applier = HttpEntitiesStateApplier(Mock())
+async def test_delete_diff_above_default_threshold(
+    mock_context: PortOceanContext,
+) -> None:
+    applier = HttpEntitiesStateApplier(mock_context)
     entities = EntityDiff(
         before=[
             Entity(identifier="1", blueprint="test"),
@@ -68,8 +75,10 @@ async def test_delete_diff_above_default_threshold() -> None:
 
 
 @pytest.mark.asyncio
-async def test_delete_diff_custom_threshold_above_threshold_not_deleted() -> None:
-    applier = HttpEntitiesStateApplier(Mock())
+async def test_delete_diff_custom_threshold_above_threshold_not_deleted(
+    mock_context: PortOceanContext,
+) -> None:
+    applier = HttpEntitiesStateApplier(mock_context)
     entities = EntityDiff(
         before=[
             Entity(identifier="1", blueprint="test"),
@@ -84,3 +93,142 @@ async def test_delete_diff_custom_threshold_above_threshold_not_deleted() -> Non
         )
 
     mock_safe_delete.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_applier_with_mock_context(
+    mock_ocean: Ocean,
+    mock_context: PortOceanContext,
+    mock_port_app_config: PortAppConfig,
+) -> None:
+    # Create an applier using the mock_context fixture
+    applier = HttpEntitiesStateApplier(mock_context)
+
+    # Create test entities
+    entity = Entity(identifier="test_entity", blueprint="test_blueprint")
+
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        event.port_app_config = mock_port_app_config
+
+        # Test the upsert method with mocked client
+        with patch.object(mock_ocean.port_client.client, "post") as mock_post:
+            mock_post.return_value = Mock(
+                status_code=200,
+                json=lambda: {
+                    "entity": {
+                        "identifier": "test_entity",
+                        "blueprint": "test_blueprint",
+                    }
+                },
+            )
+
+            result = await applier.upsert([entity], UserAgentType.exporter)
+
+            # Assert that the post method was called
+            mock_post.assert_called_once()
+            assert len(result) == 1
+            assert result[0].identifier == "test_entity"
+
+
+@pytest.mark.asyncio
+async def test_applier_one_not_upserted(
+    mock_ocean: Ocean,
+    mock_context: PortOceanContext,
+    mock_port_app_config: PortAppConfig,
+) -> None:
+    # Create an applier using the mock_context fixture
+    applier = HttpEntitiesStateApplier(mock_context)
+
+    # Create test entities
+    entity = Entity(identifier="test_entity", blueprint="test_blueprint")
+
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        # Mock the register_entity method
+        event.entity_topological_sorter.register_entity = Mock()  # type: ignore
+        event.port_app_config = mock_port_app_config
+
+        # Test the upsert method with mocked client
+        with patch.object(mock_ocean.port_client.client, "post") as mock_post:
+            mock_post.return_value = Mock(
+                status_code=404,
+                json=lambda: {"ok": False, "error": "not_found"},
+            )
+
+            result = await applier.upsert([entity], UserAgentType.exporter)
+
+            # Assert that the post method was called
+            mock_post.assert_called_once()
+            assert len(result) == 0
+            event.entity_topological_sorter.register_entity.assert_called_once_with(
+                entity
+            )
+
+
+@pytest.mark.asyncio
+async def test_applier_error_upserting(
+    mock_ocean: Ocean,
+    mock_context: PortOceanContext,
+    mock_port_app_config: PortAppConfig,
+) -> None:
+    # Create an applier using the mock_context fixture
+    applier = HttpEntitiesStateApplier(mock_context)
+
+    # Create test entities
+    entity = Entity(identifier="test_entity", blueprint="test_blueprint")
+
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        # Mock the register_entity method
+        event.entity_topological_sorter.register_entity = Mock()  # type: ignore
+        event.port_app_config = mock_port_app_config
+
+        # Test the upsert method with mocked client
+        with patch.object(mock_ocean.port_client.client, "post") as mock_post:
+            mock_post.return_value = Mock(
+                status_code=404,
+                json=lambda: {"ok": False, "error": "not_found"},
+            )
+
+            result = await applier.upsert([entity], UserAgentType.exporter)
+
+            # Assert that the post method was called
+            mock_post.assert_called_once()
+            assert len(result) == 0
+            event.entity_topological_sorter.register_entity.assert_called_once_with(
+                entity
+            )
+
+
+@pytest.mark.asyncio
+async def test_using_create_entity_helper(
+    mock_ocean: Ocean,
+    mock_context: PortOceanContext,
+    mock_port_app_config: PortAppConfig,
+) -> None:
+    # Create the applier with the mock context
+    applier = HttpEntitiesStateApplier(mock_context)
+
+    # Create test entities using the helper function
+    entity1 = create_entity("entity1", "service", {"related_to": "entity2"}, False)
+
+    # Test that entities were created correctly
+    assert entity1.identifier == "entity1"
+    assert entity1.blueprint == "service"
+    assert entity1.relations == {"related_to": "entity2"}
+    assert entity1.properties == {"mock_is_to_fail": False}
+
+    # Test the applier with these entities
+    async with event_context(EventType.RESYNC, trigger_type="machine") as event:
+        event.port_app_config = mock_port_app_config
+
+        with patch.object(mock_ocean.port_client.client, "post") as mock_post:
+            mock_post.return_value = Mock(
+                status_code=200,
+                json=lambda: {
+                    "entity": {"identifier": "entity1", "blueprint": "service"}
+                },
+            )
+
+            result = await applier.upsert([entity1], UserAgentType.exporter)
+
+            mock_post.assert_called_once()
+            assert len(result) == 1

port_ocean/tests/core/handlers/mixins/test_sync_raw.py

@@ -1,9 +1,6 @@
-from contextlib import asynccontextmanager
 from graphlib import CycleError
-from typing import Any, AsyncGenerator
+from typing import Any
 
-from httpx import Response
-from port_ocean.clients.port.client import PortClient
 from port_ocean.core.utils.entity_topological_sorter import EntityTopologicalSorter
 from port_ocean.exceptions.core import OceanAbortException
 import pytest
@@ -11,12 +8,8 @@ from unittest.mock import MagicMock, AsyncMock, patch
 from port_ocean.ocean import Ocean
 from port_ocean.context.ocean import PortOceanContext
 from port_ocean.core.handlers.port_app_config.models import (
-    EntityMapping,
-    MappingsConfig,
     PortAppConfig,
-    PortResourceConfig,
     ResourceConfig,
-    Selector,
 )
 from port_ocean.core.integrations.mixins import SyncRawMixin
 from port_ocean.core.handlers.entities_state_applier.port.applier import (
@@ -26,148 +19,11 @@ from port_ocean.core.handlers.entity_processor.jq_entity_processor import (
     JQEntityProcessor,
 )
 from port_ocean.core.models import Entity
-from port_ocean.context.event import EventContext, event_context, EventType
+from port_ocean.context.event import event_context, EventType
 from port_ocean.clients.port.types import UserAgentType
-from port_ocean.context.ocean import ocean
 from dataclasses import dataclass
 from typing import List, Optional
-
-
-@pytest.fixture
-def mock_port_client(mock_http_client: MagicMock) -> PortClient:
-    mock_port_client = PortClient(
-        MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock()
-    )
-    mock_port_client.auth = AsyncMock()
-    mock_port_client.auth.headers = AsyncMock(
-        return_value={
-            "Authorization": "test",
-            "User-Agent": "test",
-        }
-    )
-
-    mock_port_client.search_entities = AsyncMock(return_value=[])  # type: ignore
-    mock_port_client.client = mock_http_client
-    return mock_port_client
-
-
-@pytest.fixture
-def mock_http_client() -> MagicMock:
-    mock_http_client = MagicMock()
-    mock_upserted_entities = []
-
-    async def post(url: str, *args: Any, **kwargs: Any) -> Response:
-        entity = kwargs.get("json", {})
-        if entity.get("properties", {}).get("mock_is_to_fail", {}):
-            return Response(
-                404, headers=MagicMock(), json={"ok": False, "error": "not_found"}
-            )
-
-        mock_upserted_entities.append(
-            f"{entity.get('identifier')}-{entity.get('blueprint')}"
-        )
-        return Response(
-            200,
-            json={
-                "entity": {
-                    "identifier": entity.get("identifier"),
-                    "blueprint": entity.get("blueprint"),
-                }
-            },
-        )
-
-    mock_http_client.post = AsyncMock(side_effect=post)
-    return mock_http_client
-
-
-@pytest.fixture
-def mock_ocean(mock_port_client: PortClient) -> Ocean:
-    with patch("port_ocean.ocean.Ocean.__init__", return_value=None):
-        ocean_mock = Ocean(
-            MagicMock(), MagicMock(), MagicMock(), MagicMock(), MagicMock()
-        )
-        ocean_mock.config = MagicMock()
-        ocean_mock.config.port = MagicMock()
-        ocean_mock.config.port.port_app_config_cache_ttl = 60
-        ocean_mock.port_client = mock_port_client
-
-        return ocean_mock
-
-
-@pytest.fixture
-def mock_context(mock_ocean: Ocean) -> PortOceanContext:
-    context = PortOceanContext(mock_ocean)
-    ocean._app = context.app
-    return context
-
-
-@pytest.fixture
-def mock_port_app_config() -> PortAppConfig:
-    return PortAppConfig(
-        enable_merge_entity=True,
-        delete_dependent_entities=True,
-        create_missing_related_entities=False,
-        resources=[
-            ResourceConfig(
-                kind="project",
-                selector=Selector(query="true"),
-                port=PortResourceConfig(
-                    entity=MappingsConfig(
-                        mappings=EntityMapping(
-                            identifier=".id | tostring",
-                            title=".name",
-                            blueprint='"service"',
-                            properties={"url": ".web_url"},
-                            relations={},
-                        )
-                    )
-                ),
-            )
-        ],
-    )
-
-
-@pytest.fixture
-def mock_port_app_config_handler(mock_port_app_config: PortAppConfig) -> MagicMock:
-    handler = MagicMock()
-
-    async def get_config(use_cache: bool = True) -> Any:
-        return mock_port_app_config
-
-    handler.get_port_app_config = get_config
-    return handler
-
-
-@pytest.fixture
-def mock_entity_processor(mock_context: PortOceanContext) -> JQEntityProcessor:
-    return JQEntityProcessor(mock_context)
-
-
-@pytest.fixture
-def mock_resource_config() -> ResourceConfig:
-    resource = ResourceConfig(
-        kind="service",
-        selector=Selector(query="true"),
-        port=PortResourceConfig(
-            entity=MappingsConfig(
-                mappings=EntityMapping(
-                    identifier=".id",
-                    title=".name",
-                    blueprint='"service"',
-                    properties={"url": ".web_url"},
-                    relations={},
-                )
-            )
-        ),
-    )
-    return resource
-
-
-@pytest.fixture
-def mock_entities_state_applier(
-    mock_context: PortOceanContext,
-) -> HttpEntitiesStateApplier:
-    return HttpEntitiesStateApplier(mock_context)
+from port_ocean.tests.core.conftest import create_entity, no_op_event_context
 
 
 @pytest.fixture
@@ -189,27 +45,12 @@ def mock_sync_raw_mixin(
 @pytest.fixture
 def mock_sync_raw_mixin_with_jq_processor(
     mock_sync_raw_mixin: SyncRawMixin,
+    mock_context: PortOceanContext,
 ) -> SyncRawMixin:
-    mock_sync_raw_mixin._entity_processor = JQEntityProcessor(mock_context)  # type: ignore
+    mock_sync_raw_mixin._entity_processor = JQEntityProcessor(mock_context)
     return mock_sync_raw_mixin
 
 
-@asynccontextmanager
-async def no_op_event_context(
-    existing_event: EventContext,
-) -> AsyncGenerator[EventContext, None]:
-    yield existing_event
-
-
-def create_entity(
-    id: str, blueprint: str, relation: dict[str, str], is_to_fail: bool
-) -> Entity:
-    entity = Entity(identifier=id, blueprint=blueprint)
-    entity.relations = relation
-    entity.properties = {"mock_is_to_fail": is_to_fail}
-    return entity
-
-
 @pytest.mark.asyncio
 async def test_sync_raw_mixin_self_dependency(
     mock_sync_raw_mixin: SyncRawMixin,
@@ -576,6 +417,30 @@ async def test_map_entities_compared_with_port_no_port_entities_all_entities_are
     assert "entity_2" in [e.identifier for e in changed_entities]
 
 
+@pytest.mark.asyncio
+async def test_map_entities_compared_with_port_returns_original_entities_when_using_team_search_query(
+    mock_sync_raw_mixin: SyncRawMixin,
+    mock_resource_config: ResourceConfig,
+) -> None:
+
+    team_search_query = {
+        "combinator": "and",
+        "rules": [{"property": "$team", "operator": "=", "value": "my-team"}],
+    }
+
+    entities = [
+        create_entity("entity_1", "service", {}, False, team=team_search_query),
+        create_entity("entity_2", "service", {}, False, team=team_search_query),
+    ]
+
+    changed_entities = await mock_sync_raw_mixin._map_entities_compared_with_port(
+        entities, mock_resource_config, UserAgentType.exporter
+    )
+
+    assert len(changed_entities) == 2
+    assert changed_entities == entities
+
+
 @pytest.mark.asyncio
 async def test_map_entities_compared_with_port_with_existing_entities_only_changed_third_party_entities_are_mapped(
     mock_sync_raw_mixin: SyncRawMixin,

port_ocean/tests/core/utils/test_resolve_entities_diff.py

@@ -246,6 +246,58 @@ def test_are_entities_fields_equal_different_nested_relations_should_be_false()
     )
 
 
+def test_are_entities_fields_equal_null_properties_should_be_true() -> None:
+    assert (
+        are_entities_fields_equal(
+            {
+                "team": None,
+                "members": ["user1", "user2"],
+                "metadata": {"role": "admin"},
+            },
+            {"members": ["user1", "user2"], "metadata": {"role": "admin"}},
+        )
+        is True
+    )
+
+
+def test_are_entities_fields_equal_null_properties_and_real_data_in_other_entity_should_be_false() -> (
+    None
+):
+    assert (
+        are_entities_fields_equal(
+            {
+                "team": None,
+                "members": ["user1", "user2"],
+                "metadata": {"role": "admin"},
+            },
+            {
+                "team": "team_id1",
+                "members": ["user1", "user2"],
+                "metadata": {"role": "admin"},
+            },
+        )
+        is False
+    )
+
+
+def test_are_entities_fields_equal_null_properties_in_both_should_be_true() -> None:
+    assert (
+        are_entities_fields_equal(
+            {
+                "team": None,
+                "members": ["user1", "user2"],
+                "metadata": {"role": "admin"},
+            },
+            {
+                "team": None,
+                "members": ["user1", "user2"],
+                "metadata": {"role": "admin"},
+            },
+        )
+        is True
+    )
+
+
 def test_are_entities_different_identical_entities_should_be_false() -> None:
     entity1 = create_test_entity(
         "",

port_ocean/tests/test_metric.py

@@ -0,0 +1,180 @@
+import ast
+import pytest
+
+
+@pytest.mark.metric
+@pytest.mark.skip(reason="Skipping metric test until we have a way to test the metrics")
+def test_metrics() -> None:
+    """
+    Test that the metrics logged in /tmp/ocean/metric.log match expected values.
+    """
+
+    log_path = "/tmp/ocean/metric.log"
+    delay = 2
+    batch_size = 400
+    total_objects = 2000
+    magic_string = "prometheus metrics |"
+
+    # Read the file
+    with open(log_path, "r") as file:
+        content = file.read()
+
+    # Ensure the magic string is present in the content
+    assert magic_string in content, f"'{magic_string}' not found in {log_path}"
+
+    # Isolate and parse the JSON object after the magic string
+    start_idx = content.rfind(magic_string)
+    content_after_magic = content[start_idx + len(magic_string) :]
+    obj = ast.literal_eval(content_after_magic)
+
+    # ----------------------------------------------------------------------------
+    # 1. Validate Extract Duration (using original delay/batch_size logic)
+    # ----------------------------------------------------------------------------
+    num_batches = total_objects / batch_size  # e.g., 2000 / 400 = 5
+    expected_min_extract_duration = num_batches * delay  # e.g., 5 * 2 = 10
+
+    # Check "fake-person-1" extract duration is > expected_min_extract_duration
+    actual_extract_duration = obj.get("duration_seconds__fake-person-1__extract", 0)
+    assert round(actual_extract_duration) > round(expected_min_extract_duration), (
+        f"Extract duration {actual_extract_duration} not greater than "
+        f"{expected_min_extract_duration}"
+    )
+
+    # ----------------------------------------------------------------------------
+    # 2. Check Durations for Both "fake-person-1" and "fake-department-0"
+    # ----------------------------------------------------------------------------
+    # -- fake-person-1
+    transform_duration_p1 = obj.get("duration_seconds__fake-person-1__transform", 0)
+    load_duration_p1 = obj.get("duration_seconds__fake-person-1__load", 0)
+    assert (
+        transform_duration_p1 > 0
+    ), f"Expected transform duration > 0, got {transform_duration_p1}"
+    assert load_duration_p1 > 0, f"Expected load duration > 0, got {load_duration_p1}"
+
+    # -- fake-department-0
+    extract_duration_dept0 = obj.get("duration_seconds__fake-department-0__extract", 0)
+    transform_duration_dept0 = obj.get(
+        "duration_seconds__fake-department-0__transform", 0
+    )
+    load_duration_dept0 = obj.get("duration_seconds__fake-department-0__load", 0)
+
+    assert (
+        extract_duration_dept0 > 0
+    ), f"Expected department extract duration > 0, got {extract_duration_dept0}"
+    assert (
+        transform_duration_dept0 > 0
+    ), f"Expected department transform duration > 0, got {transform_duration_dept0}"
+    assert (
+        load_duration_dept0 > 0
+    ), f"Expected department load duration > 0, got {load_duration_dept0}"
+
+    # Optionally, check the "init__top_sort" duration too, if it's relevant:
+    init_top_sort = obj.get("duration_seconds__init__top_sort", 0)
+    assert init_top_sort >= 0, f"Expected init__top_sort >= 0, got {init_top_sort}"
+
+    # ----------------------------------------------------------------------------
+    # 3. Check Object Counts
+    # ----------------------------------------------------------------------------
+    # -- fake-person-1
+    person_extract_count = obj.get("object_count__fake-person-1__extract", 0)
+    person_load_count = obj.get("object_count__fake-person-1__load", 0)
+    assert person_extract_count == 2000.0, (
+        f"Expected object_count__fake-person-1__extract=2000.0, "
+        f"got {person_extract_count}"
+    )
+    assert person_load_count == 4000.0, (
+        f"Expected object_count__fake-person-1__load=4000.0, "
+        f"got {person_load_count}"
+    )
+
+    # -- fake-department-0
+    dept_extract_count = obj.get("object_count__fake-department-0__extract", 0)
+    dept_load_count = obj.get("object_count__fake-department-0__load", 0)
+    assert dept_extract_count == 5.0, (
+        f"Expected object_count__fake-department-0__extract=5.0, "
+        f"got {dept_extract_count}"
+    )
+    assert dept_load_count == 10.0, (
+        f"Expected object_count__fake-department-0__load=10.0, "
+        f"got {dept_load_count}"
+    )
+
+    # ----------------------------------------------------------------------------
+    # 4. Check Input/Upserted Counts
+    # ----------------------------------------------------------------------------
+    # -- fake-person-1
+    input_count_p1 = obj.get("input_count__fake-person-1__load", 0)
+    upserted_count_p1 = obj.get("upserted_count__fake-person-1__load", 0)
+    assert (
+        input_count_p1 == 2000.0
+    ), f"Expected input_count__fake-person-1__load=2000.0, got {input_count_p1}"
+    assert (
+        upserted_count_p1 == 2000.0
+    ), f"Expected upserted_count__fake-person-1__load=2000.0, got {upserted_count_p1}"
+
+    # -- fake-department-0
+    input_count_dept0 = obj.get("input_count__fake-department-0__load", 0)
+    upserted_count_dept0 = obj.get("upserted_count__fake-department-0__load", 0)
+    assert (
+        input_count_dept0 == 5.0
+    ), f"Expected input_count__fake-department-0__load=5.0, got {input_count_dept0}"
+    assert (
+        upserted_count_dept0 == 5.0
+    ), f"Expected upserted_count__fake-department-0__load=5.0, got {upserted_count_dept0}"
+
+    # ----------------------------------------------------------------------------
+    # 5. Check Error and Failed Counts
+    # ----------------------------------------------------------------------------
+    # -- fake-person-1
+    error_count_p1 = obj.get("error_count__fake-person-1__load", 0)
+    failed_count_p1 = obj.get("failed_count__fake-person-1__load", 0)
+    assert (
+        error_count_p1 == 0.0
+    ), f"Expected error_count__fake-person-1__load=0.0, got {error_count_p1}"
+    assert (
+        failed_count_p1 == 0.0
+    ), f"Expected failed_count__fake-person-1__load=0.0, got {failed_count_p1}"
+
+    # -- fake-department-0
+    error_count_dept0 = obj.get("error_count__fake-department-0__load", 0)
+    failed_count_dept0 = obj.get("failed_count__fake-department-0__load", 0)
+    assert (
+        error_count_dept0 == 0.0
+    ), f"Expected error_count__fake-department-0__load=0.0, got {error_count_dept0}"
+    assert (
+        failed_count_dept0 == 0.0
+    ), f"Expected failed_count__fake-department-0__load=0.0, got {failed_count_dept0}"
+
+    # ----------------------------------------------------------------------------
+    # 6. Check HTTP Request Counts (200s)
+    # ----------------------------------------------------------------------------
+    # Example: we confirm certain request counters match the sample data provided:
+    assert (
+        obj.get(
+            "http_requests_count__http://host.docker.internal:5555/v1/auth/access_token__init__load__200",
+            0,
+        )
+        == 1.0
+    ), "Expected 1.0 for auth access_token 200 requests"
+    assert (
+        obj.get(
+            "http_requests_count__http://host.docker.internal:5555/v1/integration/smoke-test-integration__init__load__200",
+            0,
+        )
+        == 5.0
+    ), "Expected 5.0 for integration/smoke-test-integration 200 requests"
+    assert (
+        obj.get(
+            "http_requests_count__http://localhost:8000/integration/department/hr/employees?limit=-1&entity_kb_size=1&latency=2000__fake-person-1__extract__200",
+            0,
+        )
+        == 1.0
+    ), "Expected 1.0 for hr/employees?limit=-1 extract 200 requests"
+    expected_requests = {
+        "http_requests_count__http://localhost:8000/integration/department/marketing/employees?limit=-1&entity_kb_size=1&latency=2000__fake-person-1__extract__200": 1.0,
+        "http_requests_count__http://localhost:8000/integration/department/finance/employees?limit=-1&entity_kb_size=1&latency=2000__fake-person-1__extract__200": 1.0,
+    }
+    for key, expected_val in expected_requests.items():
+        assert (
+            obj.get(key, 0) == expected_val
+        ), f"Expected {expected_val} for '{key}', got {obj.get(key)}"

port_ocean/utils/async_http.py

@@ -11,7 +11,10 @@ _http_client: LocalStack[httpx.AsyncClient] = LocalStack()
 def _get_http_client_context() -> httpx.AsyncClient:
     client = _http_client.top
     if client is None:
-        client = OceanAsyncClient(RetryTransport, timeout=ocean.config.client_timeout)
+        client = OceanAsyncClient(
+            RetryTransport,
+            timeout=ocean.config.client_timeout,
+        )
         _http_client.push(client)
 
     return client

{port_ocean-0.21.5.dist-info → port_ocean-0.22.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.21.5
+Version: 0.22.1
 Summary: Port Ocean is a CLI tool for managing your Port projects.
 Home-page: https://app.getport.io
 Keywords: ocean,port-ocean,port
@@ -31,6 +31,7 @@ Requires-Dist: httpx (>=0.24.1,<0.28.0)
 Requires-Dist: jinja2-time (>=0.2.0,<0.3.0) ; extra == "cli"
 Requires-Dist: jq (>=1.8.0,<2.0.0)
 Requires-Dist: loguru (>=0.7.0,<0.8.0)
+Requires-Dist: prometheus-client (>=0.21.1,<0.22.0)
 Requires-Dist: pydantic[dotenv] (>=1.10.8,<2.0.0)
 Requires-Dist: pydispatcher (>=2.0.7,<3.0.0)
 Requires-Dist: pyhumps (>=3.8.0,<4.0.0)