port-ocean 0.12.0__tar.gz → 0.12.2__tar.gz

{port_ocean-0.12.0 → port_ocean-0.12.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: port-ocean
-Version: 0.12.0
+Version: 0.12.2
 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.12.0 → port_ocean-0.12.2}/port_ocean/core/handlers/entity_processor/jq_entity_processor.py

@@ -47,37 +47,48 @@ class JQEntityProcessor(BaseEntityProcessor):
             pattern = "def env: {}; {} as $ENV | " + pattern
         return jq.compile(pattern)
 
+    @staticmethod
+    def _stop_iterator_handler(func: Any) -> Any:
+        """
+        Wrap the function to handle StopIteration exceptions.
+        Prevents StopIteration from stopping the thread and skipping further queue processing.
+        """
+
+        def inner() -> Any:
+            try:
+                return func()
+            except StopIteration:
+                return None
+
+        return inner
+
     async def _search(self, data: dict[str, Any], pattern: str) -> Any:
         try:
             loop = asyncio.get_event_loop()
             compiled_pattern = self._compile(pattern)
             func = compiled_pattern.input_value(data)
-            return await loop.run_in_executor(None, func.first)
+            return await loop.run_in_executor(
+                None, self._stop_iterator_handler(func.first)
+            )
         except Exception as exc:
             logger.debug(
-                f"Failed to search for pattern {pattern} in data {data}, {exc}"
+                f"Search failed for pattern '{pattern}' in data: {data}, Error: {exc}"
             )
             return None
 
     async def _search_as_bool(self, data: dict[str, Any], pattern: str) -> bool:
         loop = asyncio.get_event_loop()
-        start_time = loop.time()
+
         compiled_pattern = self._compile(pattern)
         func = compiled_pattern.input_value(data)
-        compile_time = loop.time() - start_time
-        value = await loop.run_in_executor(None, func.first)
-        execute_time = loop.time() - start_time - compile_time
-        logger.debug(
-            f"Search for pattern {execute_time:.2f} seconds, compile time {compile_time:.2f} seconds",
-            pattern=pattern,
-            compile_time=compile_time,
-            execute_time=execute_time,
+
+        value = await loop.run_in_executor(
+            None, self._stop_iterator_handler(func.first)
         )
         if isinstance(value, bool):
             return value
-
         raise EntityProcessorException(
-            f"Expected boolean value, got {type(value)} instead"
+            f"Expected boolean value, got value:{value} of type: {type(value)} instead"
         )
 
     async def _search_as_object(

{port_ocean-0.12.0 → port_ocean-0.12.2}/port_ocean/tests/core/handlers/entity_processor/test_jq_entity_processor.py

@@ -195,10 +195,45 @@ class TestJQEntityProcessor:
         pattern = ".foo"
         with pytest.raises(
             EntityProcessorException,
-            match="Expected boolean value, got <class 'str'> instead",
+            match="Expected boolean value, got value:bar of type: <class 'str'> instead",
         ):
             await mocked_processor._search_as_bool(data, pattern)
 
+    @pytest.mark.parametrize(
+        "pattern, expected",
+        [
+            ('.parameters[] | select(.name == "not_exists") | .value', None),
+            (
+                '.parameters[] | select(.name == "parameter_name") | .value',
+                "parameter_value",
+            ),
+            (
+                '.parameters[] | select(.name == "another_parameter") | .value',
+                "another_value",
+            ),
+        ],
+    )
+    async def test_search_fails_on_stop_iteration(
+        self, mocked_processor: JQEntityProcessor, pattern: str, expected: Any
+    ) -> None:
+        data = {
+            "parameters": [
+                {"name": "parameter_name", "value": "parameter_value"},
+                {"name": "another_parameter", "value": "another_value"},
+                {"name": "another_parameter", "value": "another_value2"},
+            ]
+        }
+        result = await mocked_processor._search(data, pattern)
+        assert result == expected
+
+    async def test_return_a_list_of_values(
+        self, mocked_processor: JQEntityProcessor
+    ) -> None:
+        data = {"parameters": ["parameter_value", "another_value", "another_value2"]}
+        pattern = ".parameters"
+        result = await mocked_processor._search(data, pattern)
+        assert result == ["parameter_value", "another_value", "another_value2"]
+
     @pytest.mark.timeout(3)
     async def test_search_performance_10000(
         self, mocked_processor: JQEntityProcessor

port_ocean-0.12.2/port_ocean/tests/utils/test_async_iterators.py

@@ -0,0 +1,45 @@
+from typing import Any, AsyncGenerator
+import asyncio
+from port_ocean.utils.async_iterators import semaphore_async_iterator
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_semaphore_async_iterator() -> None:
+    max_concurrency = 5
+    semaphore = asyncio.BoundedSemaphore(max_concurrency)
+
+    concurrent_tasks = 0
+    max_concurrent_tasks = 0
+    lock = asyncio.Lock()  # Protect shared variables
+
+    num_tasks = 20
+
+    async def mock_function() -> AsyncGenerator[str, None]:
+        nonlocal concurrent_tasks, max_concurrent_tasks
+
+        async with lock:
+            concurrent_tasks += 1
+            if concurrent_tasks > max_concurrent_tasks:
+                max_concurrent_tasks = concurrent_tasks
+
+        await asyncio.sleep(0.1)
+        yield "result"
+
+        async with lock:
+            concurrent_tasks -= 1
+
+    async def consume_iterator(async_iterator: Any) -> None:
+        async for _ in async_iterator:
+            pass
+
+    tasks = [
+        consume_iterator(semaphore_async_iterator(semaphore, mock_function))
+        for _ in range(num_tasks)
+    ]
+    await asyncio.gather(*tasks)
+
+    assert (
+        max_concurrent_tasks <= max_concurrency
+    ), f"Max concurrent tasks {max_concurrent_tasks} exceeded semaphore limit {max_concurrency}"
+    assert concurrent_tasks == 0, "Not all tasks have completed"

port_ocean-0.12.2/port_ocean/utils/async_iterators.py

@@ -0,0 +1,109 @@
+import typing
+
+import aiostream
+
+if typing.TYPE_CHECKING:
+    from asyncio import Semaphore
+
+
+async def stream_async_iterators_tasks(
+    *tasks: typing.AsyncIterable[typing.Any],
+) -> typing.AsyncIterable[typing.Any]:
+    """
+    This function takes a list of async iterators and streams the results of each iterator as they are available.
+    By using this function you can combine multiple async iterators into a single stream of results, instead of waiting
+    for each iterator to finish before starting the next one.
+
+    Usage:
+    ```python
+    async def async_iterator1():
+        for i in range(10):
+            yield i
+            await asyncio.sleep(1)
+
+    async def async_iterator2():
+        for i in range(10, 20):
+            yield i
+            await asyncio.sleep(1)
+
+    async def main():
+        async for result in stream_async_iterators_tasks([async_iterator1(), async_iterator2()]):
+            print(result)
+    ```
+
+    Caution - Before using this function, make sure that the third-party API you are calling allows the number of
+    concurrent requests you are making. If the API has a rate limit, you may need to adjust the number of concurrent
+    requests to avoid hitting the rate limit.
+
+    :param tasks: A list of async iterators
+    :return: A stream of results
+    """
+    if not tasks:
+        return
+
+    if len(tasks) == 1:
+        async for batch_items in tasks[0]:
+            yield batch_items
+        return
+
+    combine = aiostream.stream.merge(tasks[0], *tasks[1:])
+    async with combine.stream() as streamer:
+        async for batch_items in streamer:
+            yield batch_items
+
+
+async def semaphore_async_iterator(
+    semaphore: "Semaphore",
+    function: typing.Callable[[], typing.AsyncIterator[typing.Any]],
+) -> typing.AsyncIterator[typing.Any]:
+    """
+    Executes an asynchronous iterator function under a semaphore to limit concurrency.
+
+    This function ensures that the provided asynchronous iterator function is executed
+    while respecting the concurrency limit imposed by the semaphore. It acquires the
+    semaphore before executing the function and releases it after the function completes,
+    thus controlling the number of concurrent executions.
+
+    Parameters:
+        semaphore (asyncio.Semaphore | asyncio.BoundedSemaphore): The semaphore used to limit concurrency.
+        function (Callable[[], AsyncIterator[Any]]): A nullary asynchronous function, - apply arguments with `functools.partial` or an anonymous function (lambda)
+            that returns an asynchronous iterator. This function is executed under the semaphore.
+
+    Yields:
+        Any: The items yielded by the asynchronous iterator function.
+
+    Usage:
+        ```python
+        import asyncio
+
+        async def async_iterator_function(param1, param2):
+            # Your async code here
+            yield ...
+
+        async def async_generator_function():
+            # Your async code to retrieve items
+            param1 = "your_param1"
+            yield param1
+
+        async def main():
+            semaphore = asyncio.BoundedSemaphore(50)
+            param2 = "your_param2"
+
+            tasks = [
+                semaphore_async_iterator(
+                    semaphore,
+                    lambda: async_iterator_function(param1, param2) # functools.partial(async_iterator_function, param1, param2)
+                )
+                async for param1 in async_generator_function()
+            ]
+
+            async for batch in stream_async_iterators_tasks(*tasks):
+                # Process each batch
+                pass
+
+        asyncio.run(main())
+        ```
+    """
+    async with semaphore:
+        async for result in function():
+            yield result

{port_ocean-0.12.0 → port_ocean-0.12.2}/pyproject.toml

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

port_ocean-0.12.0/port_ocean/utils/async_iterators.py

@@ -1,49 +0,0 @@
-import typing
-
-import aiostream
-
-
-async def stream_async_iterators_tasks(
-    *tasks: typing.AsyncIterable[typing.Any],
-) -> typing.AsyncIterable[typing.Any]:
-    """
-    This function takes a list of async iterators and streams the results of each iterator as they are available.
-    By using this function you can combine multiple async iterators into a single stream of results, instead of waiting
-    for each iterator to finish before starting the next one.
-
-    Usage:
-    ```python
-    async def async_iterator1():
-        for i in range(10):
-            yield i
-            await asyncio.sleep(1)
-
-    async def async_iterator2():
-        for i in range(10, 20):
-            yield i
-            await asyncio.sleep(1)
-
-    async def main():
-        async for result in stream_async_iterators_tasks([async_iterator1(), async_iterator2()]):
-            print(result)
-    ```
-
-    Caution - Before using this function, make sure that the third-party API you are calling allows the number of
-    concurrent requests you are making. If the API has a rate limit, you may need to adjust the number of concurrent
-    requests to avoid hitting the rate limit.
-
-    :param tasks: A list of async iterators
-    :return: A stream of results
-    """
-    if not tasks:
-        return
-
-    if len(tasks) == 1:
-        async for batch_items in tasks[0]:
-            yield batch_items
-        return
-
-    combine = aiostream.stream.merge(tasks[0], *tasks[1:])
-    async with combine.stream() as streamer:
-        async for batch_items in streamer:
-            yield batch_items