sunholo 0.101.0__py3-none-any.whl → 0.101.3__py3-none-any.whl

sunholo/genai/process_funcs_cls.py

@@ -14,13 +14,16 @@ try:
     import proto
     from google.generativeai.types import RequestOptions
     from google.api_core import retry
+    from google.generativeai import ChatSession
 except ImportError:
     genai = None
+    ChatSession = None
 
 from .images import extract_gs_images_and_genai_upload
 
 if TYPE_CHECKING:
     from google.generativeai.protos import Part
+    from google.generativeai import ChatSession
 
 
 
@@ -369,8 +372,28 @@ class GenAIFunctionProcessor:
         log.info(f"Cleaning:\n{string}\n > to >\n{clean}")
         
         return clean
+    
+    def convert_composite_to_native(self, value):
+        """
+        Recursively converts a proto MapComposite or RepeatedComposite object to native Python types.
+
+        Args:
+            value: The proto object, which could be a MapComposite, RepeatedComposite, or a primitive.
+
+        Returns:
+            The equivalent Python dictionary, list, or primitive type.
+        """
+        if isinstance(value, proto.marshal.collections.maps.MapComposite):
+            # Convert MapComposite to a dictionary, recursively processing its values
+            return {key: self.convert_composite_to_native(val) for key, val in value.items()}
+        elif isinstance(value, proto.marshal.collections.repeated.RepeatedComposite):
+            # Convert RepeatedComposite to a list, recursively processing its elements
+            return [self.convert_composite_to_native(item) for item in value]
+        else:
+            # If it's a primitive value, return it as is
+            return value
 
-    def run_agent_loop(self, chat, content, callback=None, guardrail_max=10, loop_return=3):
+    def run_agent_loop(self, chat:ChatSession, content:list, callback=None, guardrail_max=10, loop_return=3):
         """
         Runs the agent loop, sending messages to the orchestrator, processing responses, and executing functions.
 
@@ -488,7 +511,9 @@ class GenAIFunctionProcessor:
                     fn_result_json = None
                     # Convert MapComposite to a standard Python dictionary
                     if isinstance(fn_result, proto.marshal.collections.maps.MapComposite):
-                        fn_result_json = dict(fn_result)
+                        fn_result_json = self.convert_composite_to_native(fn_result)
+                    elif isinstance(fn_result, proto.marshal.collections.repeated.RepeatedComposite):
+                        fn_result = self.convert_composite_to_native(fn_result)
                     elif isinstance(fn_result, dict):
                         fn_result_json = fn_result
                     elif isinstance(fn_result, str):

sunholo/invoke/async_class.py

@@ -13,12 +13,18 @@ class AsyncTaskRunner:
         self.retry_enabled = retry_enabled
         self.retry_kwargs = retry_kwargs or {}
 
-    def add_task(self, func: Callable[..., Any], *args: Any):
+    def add_task(self, func: Callable[..., Any], *args: Any, **kwargs: Any):
         """
-        Adds a task to the list of tasks to be executed.
+        Adds a task to the list of tasks to be executed, supporting both positional and keyword arguments.
+
+        Args:
+            func: The function to be executed.
+            *args: Positional arguments for the function.
+            **kwargs: Keyword arguments for the function.
         """
-        log.info(f"Adding task: {func.__name__} with args: {args}")
-        self.tasks.append((func.__name__, func, args))
+        log.info(f"Adding task: {func.__name__} with args: {args}, kwargs: {kwargs}")
+        # Store the function name, function itself, args, and kwargs
+        self.tasks.append((func.__name__, func, args, kwargs))
 
     async def run_async_as_completed(self) -> AsyncGenerator[Dict[str, Any], None]:
         """
@@ -34,12 +40,13 @@ class AsyncTaskRunner:
         task_infos = []
 
         # Start all tasks and their corresponding heartbeats
-        for name, func, args in self.tasks:
+        for name, func, args, kwargs in self.tasks:
             # Create an event to signal task completion to the heartbeat
+            log.info(f"Executing task: {name=}, {func=} with args: {args}, kwargs: {kwargs}")
             completion_event = asyncio.Event()
 
             # Start the main task with retries
-            task_coro = self._run_with_retries(name, func, *args, queue=queue, completion_event=completion_event)
+            task_coro = self._run_with_retries(name, func, args, kwargs, queue, completion_event)            
             task = asyncio.create_task(task_coro)
 
             # Start the heartbeat coroutine
@@ -98,11 +105,18 @@ class AsyncTaskRunner:
         await queue.put(None)
         log.info("Monitor: Sent sentinel to queue")
 
-    async def _run_with_retries(self, name: str, func: Callable[..., Any], *args: Any, queue: asyncio.Queue, completion_event: asyncio.Event) -> None:
+    async def _run_with_retries(self, 
+                                name: str,
+                                func: Callable[..., Any], 
+                                args: tuple,
+                                kwargs: dict,
+                                queue: asyncio.Queue, 
+                                completion_event: asyncio.Event) -> None:
         """
         Executes a task with optional retries and sends completion or error messages to the queue.
         """
         try:
+            log.info(f"run_with_retries: {name=}, {func=} with args: {args}, kwargs: {kwargs}")
             if self.retry_enabled:
                 retry_kwargs = {
                     'wait': wait_random_exponential(multiplier=1, max=60),
@@ -113,13 +127,13 @@ class AsyncTaskRunner:
                 async for attempt in AsyncRetrying(**retry_kwargs):
                     with attempt:
                         log.info(f"Starting task '{name}' with retry")
-                        result = await self._execute_task(func, *args)
+                        result = await self._execute_task(func, *args, **kwargs)
                         await queue.put({'type': 'task_complete', 'func_name': name, 'result': result})
                         log.info(f"Sent 'task_complete' message for task '{name}'")
                         return
             else:
                 log.info(f"Starting task '{name}' with no retry")
-                result = await self._execute_task(func, *args)
+                result = await self._execute_task(func, *args, **kwargs)
                 await queue.put({'type': 'task_complete', 'func_name': name, 'result': result})
                 log.info(f"Sent 'task_complete' message for task '{name}'")
         except Exception as e:
@@ -128,24 +142,24 @@ class AsyncTaskRunner:
             log.info(f"Sent 'task_error' message for task '{name}'")
         finally:
             log.info(f"Task '{name}' completed.")
-            # Set the completion event after sending the message
             completion_event.set()
 
-    async def _execute_task(self, func: Callable[..., Any], *args: Any) -> Any:
+    async def _execute_task(self, func: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
         """
         Executes the given task function and returns its result.
 
         Args:
             func (Callable): The callable to execute.
-            *args: Arguments to pass to the callable.
+            *args: Positional arguments to pass to the callable.
+            **kwargs: Keyword arguments to pass to the callable.
 
         Returns:
             Any: The result of the task.
         """
         if asyncio.iscoroutinefunction(func):
-            return await func(*args)
+            return await func(*args, **kwargs)
         else:
-            return await asyncio.to_thread(func, *args)
+            return await asyncio.to_thread(func, *args, **kwargs)
 
     async def _send_heartbeat(self, func_name: str, completion_event: asyncio.Event, queue: asyncio.Queue, interval: int = 2):
         """
@@ -174,5 +188,4 @@ class AsyncTaskRunner:
         except asyncio.CancelledError:
             log.info(f"Heartbeat for task '{func_name}' has been canceled")
         finally:
-            log.info(f"Heartbeat for task '{func_name}' stopped")
-
+            log.info(f"Heartbeat for task '{func_name}' stopped")

sunholo/langfuse/prompts.py

@@ -6,17 +6,49 @@ def load_prompt_from_yaml(key, prefix="sunholo", load_from_file=False, f_string=
     """
     Returns a string you can use with prompts.
 
-    Will first try to load from the Langfuse prompt library, if unavailable will look in promptConfig type file.
+    If load_from_file=False, by default it will try to load from Langfuse, if fails (which is laggy so not ideal) then load from file.
+
+    Prompts on Langfuse should be specified with a name with {prefix}-{key} e.g. "sunholo-hello"
+    
+    Prompts in files will use yaml:
+
+    ```yaml
+    kind: promptConfig
+    apiVersion: v1
+    prompts:
+    sunholo:
+        hello: |
+            Say hello to {name} 
+    ```
+
+    And load via utils.ConfigManager:
+
+    ```python
+    # equivalent to load_prompt_from_yaml("hello", load_from_file=True)
+    config = ConfigManager("sunholo")
+    config.promptConfig("hello")
+    ```
 
     If f_string is True will be in a Langchain style prompt e.g. { one brace }
-    If f_string is False will be Langfuse style prompt e.g. {{ two braces }}
+    If f_string is False will be Langfuse style prompt e.g. {{ two braces }} - see https://langfuse.com/docs/prompts/get-started
 
     Example:
 
     ```python
     from sunholo.langfuse.prompts import load_prompt_from_yaml
-    from langchain_core.prompts import PromptTemplate
-    
+    # f_string
+    hello_template = load_prompt_from_yaml("hello")
+    hello_template.format(name="Bob")
+
+    #langfuse style
+    hello_template = load_prompt_from_yaml("hello", f_string=False)
+    hello_template.compile(name="Bob")
+
+    # if prompt not available on langfuse, will attempt to load from local promptConfig file
+    hello_template = load_prompt_from_yaml("hello", load_from_file=True)
+
+    ```
+
     """
     config = ConfigManager(prefix)
     if load_from_file:

{sunholo-0.101.0.dist-info → sunholo-0.101.3.dist-info}/METADATA

@@ -1,9 +1,9 @@
 Metadata-Version: 2.1
 Name: sunholo
-Version: 0.101.0
+Version: 0.101.3
 Summary: Large Language Model DevOps - a package to help deploy LLMs to the Cloud.
 Home-page: https://github.com/sunholo-data/sunholo-py
-Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.101.0.tar.gz
+Download-URL: https://github.com/sunholo-data/sunholo-py/archive/refs/tags/v0.101.3.tar.gz
 Author: Holosun ApS
 Author-email: multivac@sunholo.com
 License: Apache License, Version 2.0

{sunholo-0.101.0.dist-info → sunholo-0.101.3.dist-info}/RECORD

@@ -88,16 +88,16 @@ sunholo/gcs/metadata.py,sha256=oQLcXi4brsZ74aegWyC1JZmhlaEV270HS5_UWtAYYWE,898
 sunholo/genai/__init__.py,sha256=dBl6IA3-Fx6-Vx81r0XqxHlUq6WeW1iDX188dpChu8s,115
 sunholo/genai/images.py,sha256=WaeO705mK0BOz1k7OwsGslw7qF1WiyE_zsueYt07vV8,1191
 sunholo/genai/init.py,sha256=yG8E67TduFCTQPELo83OJuWfjwTnGZsyACospahyEaY,687
-sunholo/genai/process_funcs_cls.py,sha256=VvbTjyGQ_dq0xiEUx-Zn0ZomKbKTZwuoWdiWeestRfM,27419
+sunholo/genai/process_funcs_cls.py,sha256=krjhwruW-7OUR0gEOPC5Ew9KOoAoTWDMW5HfvpvuPNM,28755
 sunholo/genai/safety.py,sha256=mkFDO_BeEgiKjQd9o2I4UxB6XI7a9U-oOFjZ8LGRUC4,1238
 sunholo/invoke/__init__.py,sha256=o1RhwBGOtVK0MIdD55fAIMCkJsxTksi8GD5uoqVKI-8,184
-sunholo/invoke/async_class.py,sha256=Wkrv3exjN3aDQdI1Q4tv8I8xSloKgdz_LzGomayfLhw,7734
+sunholo/invoke/async_class.py,sha256=DViVOHsuir7Zrfa3tVKgvz5wLCfXba15XryWGuMjKYI,8540
 sunholo/invoke/direct_vac_func.py,sha256=GXSCMkC6vOWGUtQjxy-ZpTrMvJa3CgcW-y9mDpJwWC8,9533
 sunholo/invoke/invoke_vac_utils.py,sha256=sJc1edHTHMzMGXjji1N67c3iUaP7BmAL5nj82Qof63M,2053
 sunholo/langfuse/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sunholo/langfuse/callback.py,sha256=jl0SZsFS53uMW9DGeM9SOL_EsRZsba0wwFGLqKzu9_U,1684
 sunholo/langfuse/evals.py,sha256=fQBaC0dBTYfgCzyfv9QBRvUfc9f42lbwQAeZmynaHO8,3841
-sunholo/langfuse/prompts.py,sha256=3Zo-YX2YpZdKNAGKjlGePXb8t8FisA9BrraA6tO7RHM,1422
+sunholo/langfuse/prompts.py,sha256=9TkmT2A-P4YRlk7sWz_EYk6yASxPKU8jhM7jAg9ND_Q,2330
 sunholo/llamaindex/__init__.py,sha256=DlY_cHWCsVEV1C5WBgDdHRgOMlJc8pDoCRukUJ8PT9w,88
 sunholo/llamaindex/get_files.py,sha256=6rhXCDqQ_lrIapISQ_OYQDjiSATXvS_9m3qq53-oIl0,781
 sunholo/llamaindex/import_files.py,sha256=Bnic5wz8c61af9Kwq8KSrNBbc4imYnzMtBCb2jzSImI,6224
@@ -147,9 +147,9 @@ sunholo/vertex/init.py,sha256=1OQwcPBKZYBTDPdyU7IM4X4OmiXLdsNV30C-fee2scQ,2875
 sunholo/vertex/memory_tools.py,sha256=tBZxqVZ4InTmdBvLlOYwoSEWu4-kGquc-gxDwZCC4FA,7667
 sunholo/vertex/safety.py,sha256=S9PgQT1O_BQAkcqauWncRJaydiP8Q_Jzmu9gxYfy1VA,2482
 sunholo/vertex/type_dict_to_json.py,sha256=uTzL4o9tJRao4u-gJOFcACgWGkBOtqACmb6ihvCErL8,4694
-sunholo-0.101.0.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
-sunholo-0.101.0.dist-info/METADATA,sha256=f5ACnI-b0miaBTKmVuiOB6xgtIcwb9QXDq3s__-_3Aw,8312
-sunholo-0.101.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-sunholo-0.101.0.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
-sunholo-0.101.0.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
-sunholo-0.101.0.dist-info/RECORD,,
+sunholo-0.101.3.dist-info/LICENSE.txt,sha256=SdE3QjnD3GEmqqg9EX3TM9f7WmtOzqS1KJve8rhbYmU,11345
+sunholo-0.101.3.dist-info/METADATA,sha256=X_RjEUyzY8ejvVlwkm7Pf1GIkAxybLMR0v2HpKentr4,8312
+sunholo-0.101.3.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+sunholo-0.101.3.dist-info/entry_points.txt,sha256=bZuN5AIHingMPt4Ro1b_T-FnQvZ3teBes-3OyO0asl4,49
+sunholo-0.101.3.dist-info/top_level.txt,sha256=wt5tadn5--5JrZsjJz2LceoUvcrIvxjHJe-RxuudxAk,8
+sunholo-0.101.3.dist-info/RECORD,,