port-ocean 0.5.3rc1__tar.gz → 0.5.5__tar.gz

{port_ocean-0.5.3rc1 → port_ocean-0.5.5}/PKG-INFO

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

@@ -1,6 +1,5 @@
 import asyncio
 import functools
-from asyncio import TaskGroup
 from functools import lru_cache
 from typing import Any
 
@@ -22,15 +21,13 @@ class JQEntityProcessor(BaseEntityProcessor):
     """
 
     @lru_cache
-    async def _compile(self, pattern: str) -> Any:
-        loop = asyncio.get_event_loop()
-        compiler = functools.partial(jq.compile, pattern)
-        return await loop.run_in_executor(None, compiler)
+    def _compile(self, pattern: str) -> Any:
+        return jq.compile(pattern)
 
     async def _search(self, data: dict[str, Any], pattern: str) -> Any:
         try:
             loop = asyncio.get_event_loop()
-            compiled_pattern = await self._compile(pattern)
+            compiled_pattern = self._compile(pattern)
             first_value_callable = functools.partial(compiled_pattern.first, data)
             return await loop.run_in_executor(None, first_value_callable)
         except Exception:
@@ -38,7 +35,7 @@ class JQEntityProcessor(BaseEntityProcessor):
 
     async def _search_as_bool(self, data: dict[str, Any], pattern: str) -> bool:
         loop = asyncio.get_event_loop()
-        compiled_pattern = await self._compile(pattern)
+        compiled_pattern = self._compile(pattern)
         first_value_callable = functools.partial(compiled_pattern.first, data)
         value = await loop.run_in_executor(None, first_value_callable)
 
@@ -53,14 +50,13 @@ class JQEntityProcessor(BaseEntityProcessor):
         self, data: dict[str, Any], obj: dict[str, Any]
     ) -> dict[str, Any | None]:
         search_tasks = {}
-        with TaskGroup() as tg:
-            for key, value in obj.items():
-                if isinstance(value, dict):
-                    search_tasks[key] = tg.create_task(
-                        self._search_as_object(data, value)
-                    )
-                else:
-                    search_tasks[key] = tg.create_task(self._search(data, value))
+        for key, value in obj.items():
+            if isinstance(value, dict):
+                search_tasks[key] = asyncio.create_task(
+                    self._search_as_object(data, value)
+                )
+            else:
+                search_tasks[key] = asyncio.create_task(self._search(data, value))
 
         result: dict[str, Any | None] = {}
         for key, task in search_tasks.items():
@@ -74,17 +70,16 @@ class JQEntityProcessor(BaseEntityProcessor):
     async def _calculate_entities(
         self, mapping: ResourceConfig, raw_data: list[dict[str, Any]]
     ) -> list[Entity]:
-        async def calculate_raw(data: dict[str, Any]) -> Entity:
+        async def calculate_raw(data: dict[str, Any]) -> dict[str, Any]:
             should_run = await self._search_as_bool(data, mapping.selector.query)
             if should_run and mapping.port.entity:
-                return Entity.parse_obj(
-                    await self._search_as_object(
-                        data, mapping.port.entity.mappings.dict(exclude_unset=True)
-                    )
+                return await self._search_as_object(
+                    data, mapping.port.entity.mappings.dict(exclude_unset=True)
                 )
+            return {}
 
         entities_tasks = [asyncio.create_task(calculate_raw(data)) for data in raw_data]
-        entities = asyncio.gather(*entities_tasks)
+        entities = await asyncio.gather(*entities_tasks)
 
         return [
             Entity.parse_obj(entity_data)

{port_ocean-0.5.3rc1 → port_ocean-0.5.5}/port_ocean/utils/cache.py

@@ -1,14 +1,20 @@
 import functools
+import hashlib
 from typing import Callable, AsyncIterator, Any
-
 from port_ocean.context.event import event
 
 AsyncIteratorCallable = Callable[..., AsyncIterator[list[Any]]]
 
 
-def cache_iterator_result(
-    cache_key: str,
-) -> Callable[[AsyncIteratorCallable], AsyncIteratorCallable]:
+def hash_func(function_name: str, *args: Any, **kwargs: Any) -> str:
+    args_str = str(args)
+    kwargs_str = str(kwargs)
+    concatenated_string = args_str + kwargs_str
+    hash_object = hashlib.sha256(concatenated_string.encode())
+    return f"{function_name}_{hash_object.hexdigest()}"
+
+
+def cache_iterator_result() -> Callable[[AsyncIteratorCallable], AsyncIteratorCallable]:
     """
     This decorator caches the results of an async iterator function. It checks if the result is already in the cache
     and if not, it fetches the all the data and caches it at ocean.attributes cache the end of the iteration.
@@ -18,9 +24,12 @@ def cache_iterator_result(
     For example, you can use this to cache data coming back from the third-party API to avoid making the same request
     multiple times for each kind.
 
+    The caching mechanism also detects changes in parameters.
+    If a function is called with different parameter values, it will be stored in different hash keys for each unique call.
+
     Usage:
     ```python
-    @cache_iterator_result("my_cache_key")
+    @cache_iterator_result()
     async def my_async_iterator_function():
         # Your code here
     ```
@@ -29,6 +38,9 @@ def cache_iterator_result(
     def decorator(func: AsyncIteratorCallable) -> AsyncIteratorCallable:
         @functools.wraps(func)
         async def wrapper(*args: Any, **kwargs: Any) -> Any:
+            # Create Hash key from function name, args and kwargs
+            cache_key = hash_func(func.__name__, *args, **kwargs)
+
             # Check if the result is already in the cache
             if cache := event.attributes.get(cache_key):
                 yield cache

{port_ocean-0.5.3rc1 → port_ocean-0.5.5}/pyproject.toml

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