agently 4.0.6.11__tar.gz → 4.0.7.1__tar.gz

{agently-4.0.6.11 → agently-4.0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agently
-Version: 4.0.6.11
+Version: 4.0.7.1
 Summary: 
 License: Apache-2.0
 License-File: LICENSE

{agently-4.0.6.11 → agently-4.0.7.1}/agently/_default_settings.yaml

@@ -43,6 +43,7 @@ runtime:
   show_model_logs: False
   show_tool_logs: False
   show_trigger_flow_logs: False
+  httpx_log_level: "WARNING"
 plugins:
   ToolManager:
-    activate: AgentlyToolManager
+    activate: AgentlyToolManager

{agently-4.0.6.11 → agently-4.0.7.1}/agently/base.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import logging
 from typing import Any, Literal, Type, TYPE_CHECKING, TypeVar, Generic, cast
 
 from agently.utils import Settings, create_logger, FunctionShifter, DataFormatter
@@ -37,6 +38,10 @@ _hook_default_event_handlers(event_center)
 async_system_message = event_center.async_system_message
 system_message = event_center.system_message
 logger = create_logger()
+httpx_level_name = settings.get("runtime.httpx_log_level", "WARNING")
+httpx_level = getattr(logging, str(httpx_level_name).upper(), logging.WARNING)
+logging.getLogger("httpx").setLevel(httpx_level)
+logging.getLogger("httpcore").setLevel(httpx_level)
 tool = Tool(plugin_manager, settings)
 _agently_messenger = event_center.create_messenger("Agently")
 
@@ -70,11 +75,13 @@ settings.update_mappings(
                     "runtime.show_model_logs": True,
                     "runtime.show_tool_logs": True,
                     "runtime.show_trigger_flow_logs": True,
+                    "runtime.httpx_log_level": "INFO",
                 },
                 False: {
                     "runtime.show_model_logs": False,
                     "runtime.show_tool_logs": False,
                     "runtime.show_trigger_flow_logs": False,
+                    "runtime.httpx_log_level": "WARNING",
                 },
             }
         }
@@ -117,7 +124,16 @@ class AgentlyMain(Generic[A]):
         self.tool = tool
         self.AgentType = AgentType
 
-        self.set_settings = self.settings.set_settings
+        def set_settings(key: str, value: "SerializableValue", *, auto_load_env: bool = False):
+            self.settings.set_settings(key, value, auto_load_env=auto_load_env)
+            if key in ("runtime.httpx_log_level", "debug"):
+                level_name = self.settings.get("runtime.httpx_log_level", "WARNING")
+                level = getattr(logging, str(level_name).upper(), logging.WARNING)
+                logging.getLogger("httpx").setLevel(level)
+                logging.getLogger("httpcore").setLevel(level)
+            return self
+
+        self.set_settings = set_settings
 
     def set_debug_console(self, debug_console_status: Literal["ON", "OFF"]):
         match debug_console_status:

{agently-4.0.6.11 → agently-4.0.7.1}/agently/builtins/plugins/PromptGenerator/AgentlyPromptGenerator.py

@@ -589,13 +589,29 @@ class AgentlyPromptGenerator(PromptGenerator):
         fields = {}
         validators = {}
 
-        def ensure_list_and_cast(v: Any, target_type: type):
+        def ensure_list_and_cast(v: Any, target_type: Any):
             if not isinstance(v, list):
                 v = [v]
-            return [
-                (target_type(item) if target_type is not Any and not isinstance(item, target_type) else item)
-                for item in v
-            ]
+            casted = []
+            for item in v:
+                if target_type is Any or not isinstance(target_type, type):
+                    casted.append(item)
+                    continue
+                target_type = cast(type, target_type)
+                if isinstance(item, target_type):
+                    casted.append(item)
+                    continue
+                if isinstance(item, Mapping):
+                    model_validate = getattr(target_type, "model_validate", None)
+                    if callable(model_validate):
+                        casted.append(model_validate(item))
+                        continue
+                    parse_obj = getattr(target_type, "parse_obj", None)
+                    if callable(parse_obj):
+                        casted.append(parse_obj(item))
+                        continue
+                casted.append(target_type(item))
+            return casted
 
         if isinstance(schema, Mapping):
             for field_name, field_type_schema in schema.items():

{agently-4.0.6.11 → agently-4.0.7.1}/agently/builtins/tools/Search.py

@@ -103,7 +103,7 @@ class Search:
         ] = "us-en",
         options: dict[str, Any] | None = None,
     ):
-        LazyImport.import_package("ddgs")
+        LazyImport.import_package("ddgs", version_constraint=">=9.10.0")
         from ddgs import DDGS
 
         self.proxy = proxy

{agently-4.0.6.11 → agently-4.0.7.1}/agently/core/ModelRequest.py

@@ -153,6 +153,11 @@ class ModelResponseResult:
                         return await self._response_parser.async_get_data(type=type)
         return await self._response_parser.async_get_data(type=type)
 
+    @overload
+    async def async_get_data_object(
+        self,
+    ) -> "BaseModel | None": ...
+
     @overload
     async def async_get_data_object(
         self,
@@ -432,6 +437,9 @@ class ModelRequest:
         self.get_data = FunctionShifter.syncify(self.async_get_data)
         self.get_data_object = FunctionShifter.syncify(self.async_get_data_object)
 
+        self.start = self.get_data
+        self.async_start = self.async_get_data
+
     def set_prompt(
         self,
         key: "PromptStandardSlot | str",
@@ -464,7 +472,7 @@ class ModelRequest:
         prompt: Any,
         mappings: dict[str, Any] | None = None,
     ):
-        self.prompt.set("system", ["YOU MUST REACT AND RESPOND AS {system.role}!"])
+        self.prompt.set("system", ["YOU MUST REACT AND RESPOND AS {system.your_role}!"])
         self.prompt.set("system.your_role", prompt, mappings)
         return self
 

{agently-4.0.6.11 → agently-4.0.7.1}/agently/core/TriggerFlow/BluePrint.py

@@ -132,6 +132,7 @@ class TriggerFlowBluePrint:
         *,
         execution_id: str | None = None,
         skip_exceptions: bool = False,
+        concurrency: int | None = None,
     ):
         handlers_snapshot: TriggerFlowAllHandlers = {
             "event": {k: v.copy() for k, v in self._handlers["event"].items()},
@@ -143,6 +144,7 @@ class TriggerFlowBluePrint:
             trigger_flow=trigger_flow,
             id=execution_id,
             skip_exceptions=skip_exceptions,
+            concurrency=concurrency,
         )
 
     def copy(self, *, name: str | None = None):

{agently-4.0.6.11 → agently-4.0.7.1}/agently/core/TriggerFlow/Execution.py

@@ -16,6 +16,7 @@
 import uuid
 import asyncio
 import warnings
+from contextvars import ContextVar
 
 from typing import Any, Literal, TYPE_CHECKING
 
@@ -37,6 +38,7 @@ class TriggerFlowExecution:
         trigger_flow: "TriggerFlow",
         id: str | None = None,
         skip_exceptions: bool = False,
+        concurrency: int | None = None,
     ):
         # Basic Attributions
         self.id = id if id is not None else uuid.uuid4().hex
@@ -45,6 +47,11 @@ class TriggerFlowExecution:
         self._runtime_data = RuntimeData()
         self._system_runtime_data = RuntimeData()
         self._skip_exceptions = skip_exceptions
+        self._concurrency_semaphore = asyncio.Semaphore(concurrency) if concurrency and concurrency > 0 else None
+        self._concurrency_depth = ContextVar(
+            f"trigger_flow_execution_concurrency_depth_{ self.id }",
+            default=0,
+        )
 
         # Settings
         self.settings = Settings(
@@ -126,19 +133,29 @@ class TriggerFlowExecution:
                     },
                     self.settings,
                 )
-                tasks.append(
-                    asyncio.ensure_future(
-                        FunctionShifter.asyncify(handler)(
-                            TriggerFlowEventData(
-                                trigger_event=trigger_event,
-                                trigger_type=trigger_type,
-                                value=value,
-                                execution=self,
-                                _layer_marks=_layer_marks,
-                            )
-                        )
+                async def run_handler(handler_func):
+                    if self._concurrency_semaphore is None:
+                        return await handler_func
+                    depth = self._concurrency_depth.get()
+                    token = self._concurrency_depth.set(depth + 1)
+                    try:
+                        if depth > 0:
+                            return await handler_func
+                        async with self._concurrency_semaphore:
+                            return await handler_func
+                    finally:
+                        self._concurrency_depth.reset(token)
+
+                handler_task = FunctionShifter.asyncify(handler)(
+                    TriggerFlowEventData(
+                        trigger_event=trigger_event,
+                        trigger_type=trigger_type,
+                        value=value,
+                        execution=self,
+                        _layer_marks=_layer_marks,
                     )
                 )
+                tasks.append(asyncio.ensure_future(run_handler(handler_task)))
 
         if tasks:
             await asyncio.gather(*tasks, return_exceptions=self._skip_exceptions)

{agently-4.0.6.11 → agently-4.0.7.1}/agently/core/TriggerFlow/TriggerFlow.py

@@ -99,13 +99,19 @@ class TriggerFlow:
             self._blue_print.chunks[handler_or_name.__name__] = chunk
             return chunk
 
-    def create_execution(self, *, skip_exceptions: bool | None = None):
+    def create_execution(
+        self,
+        *,
+        skip_exceptions: bool | None = None,
+        concurrency: int | None = None,
+    ):
         execution_id = uuid.uuid4().hex
         skip_exceptions = skip_exceptions if skip_exceptions is not None else self._skip_exceptions
         execution = self._blue_print.create_execution(
             self,
             execution_id=execution_id,
             skip_exceptions=skip_exceptions,
+            concurrency=concurrency,
         )
         self._executions[execution_id] = execution
         return execution
@@ -118,8 +124,14 @@ class TriggerFlow:
             if execution.id in self._executions:
                 del self._executions[execution.id]
 
-    async def async_start_execution(self, initial_value: Any, *, wait_for_result: bool = False):
-        execution = self.create_execution()
+    async def async_start_execution(
+        self,
+        initial_value: Any,
+        *,
+        wait_for_result: bool = False,
+        concurrency: int | None = None,
+    ):
+        execution = self.create_execution(concurrency=concurrency)
         await execution.async_start(initial_value, wait_for_result=wait_for_result)
         return execution
 
@@ -192,8 +204,9 @@ class TriggerFlow:
         *,
         wait_for_result: bool = True,
         timeout: int | None = 10,
+        concurrency: int | None = None,
     ):
-        execution = await self.async_start_execution(initial_value)
+        execution = await self.async_start_execution(initial_value, concurrency=concurrency)
         if wait_for_result:
             return await execution.async_get_result(timeout=timeout)
 
@@ -202,8 +215,9 @@ class TriggerFlow:
         initial_value: Any = None,
         *,
         timeout: int | None = 10,
+        concurrency: int | None = None,
     ):
-        execution = self.create_execution()
+        execution = self.create_execution(concurrency=concurrency)
         return execution.get_async_runtime_stream(
             initial_value,
             timeout=timeout,
@@ -213,9 +227,10 @@ class TriggerFlow:
         self,
         initial_value: Any = None,
         *,
-        timeout: int | None = 10,
+        timeout: float | None = 10.0,
+        concurrency: int | None = None,
     ):
-        execution = self.create_execution()
+        execution = self.create_execution(concurrency=concurrency)
         return execution.get_runtime_stream(
             initial_value,
             timeout=timeout,

{agently-4.0.6.11 → agently-4.0.7.1}/agently/core/TriggerFlow/process/BaseProcess.py

@@ -14,7 +14,7 @@
 
 
 import uuid
-from asyncio import Event
+from asyncio import Event, Semaphore
 from threading import Lock
 
 from typing import Callable, Any, Literal, TYPE_CHECKING, overload, cast
@@ -266,11 +266,13 @@ class TriggerFlowBaseProcess:
         self,
         *chunks: "TriggerFlowChunk | TriggerFlowHandler | tuple[str, TriggerFlowHandler]",
         side_branch: bool = False,
+        concurrency: int | None = None,
     ):
         batch_trigger = f"Batch-{ uuid.uuid4().hex }"
         results = {}
         triggers_to_wait = {}
         trigger_to_chunk_name = {}
+        semaphore = Semaphore(concurrency) if concurrency and concurrency > 0 else None
 
         async def wait_all_chunks(data: "TriggerFlowEventData"):
             if data.event in triggers_to_wait:
@@ -292,13 +294,25 @@ class TriggerFlowBaseProcess:
                 chunk = self._flow_chunk(chunk_name)(chunk_func)
             else:
                 chunk = self._flow_chunk(chunk.__name__)(chunk) if callable(chunk) else chunk
+            typed_chunk = cast(TriggerFlowChunk, chunk)
             triggers_to_wait[chunk.trigger] = False
             trigger_to_chunk_name[chunk.trigger] = chunk.name
             results[chunk.name] = None
+
+            if semaphore is None:
+                handler = typed_chunk.async_call
+            else:
+                def make_handler(bound_chunk: TriggerFlowChunk):
+                    async def handler(data: "TriggerFlowEventData"):
+                        async with semaphore:
+                            return await bound_chunk.async_call(data)
+                    return handler
+                handler = make_handler(typed_chunk)
+
             self._blue_print.add_handler(
                 self.trigger_type,
                 self.trigger_event,
-                chunk.async_call,
+                handler,
             )
             self._blue_print.add_event_handler(chunk.trigger, wait_all_chunks)
 

{agently-4.0.6.11 → agently-4.0.7.1}/agently/core/TriggerFlow/process/ForEachProcess.py

@@ -22,7 +22,7 @@ from agently.utils import RuntimeDataNamespace
 
 
 class TriggerFlowForEachProcess(TriggerFlowBaseProcess):
-    def for_each(self):
+    def for_each(self, *, concurrency: int | None = None):
         for_each_id = uuid.uuid4().hex
         for_each_block_data = TriggerFlowBlockData(
             outer_block=self._block_data,
@@ -31,6 +31,7 @@ class TriggerFlowForEachProcess(TriggerFlowBaseProcess):
             },
         )
         send_item_trigger = f"ForEach-{ for_each_id }-Send"
+        semaphore = asyncio.Semaphore(concurrency) if concurrency and concurrency > 0 else None
 
         async def send_items(data: "TriggerFlowEventData"):
             data.layer_in()
@@ -38,33 +39,38 @@ class TriggerFlowForEachProcess(TriggerFlowBaseProcess):
             assert for_each_instance_id is not None
 
             send_tasks = []
-            if not isinstance(data.value, str) and isinstance(data.value, Sequence):
-                items = list(data.value)
-                for item in items:
-                    data.layer_in()
-                    item_id = data.layer_mark
-                    assert item_id is not None
-                    data._system_runtime_data.set(f"for_each_results.{ for_each_instance_id }.{ item_id }", EMPTY)
-                    send_tasks.append(
-                        data.async_emit(
-                            send_item_trigger,
-                            item,
-                            data._layer_marks.copy(),
-                        )
-                    )
-                    data.layer_out()
-                await asyncio.gather(*send_tasks)
-            else:
+            def prepare_item(item):
                 data.layer_in()
                 item_id = data.layer_mark
                 assert item_id is not None
+                layer_marks = data._layer_marks.copy()
                 data._system_runtime_data.set(f"for_each_results.{ for_each_instance_id }.{ item_id }", EMPTY)
-                await data.async_emit(
-                    send_item_trigger,
-                    data.value,
-                    data._layer_marks.copy(),
-                )
                 data.layer_out()
+                return item_id, layer_marks, item
+
+            async def emit_item(item, layer_marks):
+                if semaphore is None:
+                    await data.async_emit(
+                        send_item_trigger,
+                        item,
+                        layer_marks,
+                    )
+                else:
+                    async with semaphore:
+                        await data.async_emit(
+                            send_item_trigger,
+                            item,
+                            layer_marks,
+                        )
+            if not isinstance(data.value, str) and isinstance(data.value, Sequence):
+                items = list(data.value)
+                for item in items:
+                    _, layer_marks, item_value = prepare_item(item)
+                    send_tasks.append(emit_item(item_value, layer_marks))
+                await asyncio.gather(*send_tasks)
+            else:
+                _, layer_marks, item_value = prepare_item(data.value)
+                await emit_item(item_value, layer_marks)
 
         self.to(send_items)
 

{agently-4.0.6.11 → agently-4.0.7.1}/agently/utils/DataFormatter.py

@@ -56,15 +56,21 @@ class DataFormatter:
             if issubclass(value, BaseModel):
                 extracted_value = {}
                 for name, field in value.model_fields.items():
+                    annotation = field.annotation
+                    if hasattr(field, "rebuild_annotation"):
+                        try:
+                            annotation = field.rebuild_annotation()
+                        except Exception:
+                            annotation = field.annotation
                     extracted_value.update(
                         {
                             name: (
                                 (
-                                    DataFormatter.sanitize(field.annotation, remain_type=remain_type),
+                                    DataFormatter.sanitize(annotation, remain_type=remain_type),
                                     field.description,
                                 )
                                 if field.description
-                                else (DataFormatter.sanitize(field.annotation, remain_type=remain_type),)
+                                else (DataFormatter.sanitize(annotation, remain_type=remain_type),)
                             )
                         }
                     )

{agently-4.0.6.11 → agently-4.0.7.1}/agently/utils/DataLocator.py

@@ -21,6 +21,101 @@ if TYPE_CHECKING:
 
 
 class DataLocator:
+    @staticmethod
+    def _locate_path_parts(
+        result: Any,
+        path_parts: list[str],
+        *,
+        style: Literal["dot", "slash"],
+        default: Any,
+    ):
+        if not path_parts:
+            return result
+        path_part = path_parts[0]
+        remaining = path_parts[1:]
+        if style == "dot":
+            if "[" in path_part:
+                path_key_and_index = path_part.split("[")
+                path_key = path_key_and_index[0]
+                path_index = path_key_and_index[1][:-1]
+                if isinstance(result, Mapping):
+                    result = result.get(path_key, default)
+                else:
+                    return default
+                if path_index in ("*", ""):
+                    if not isinstance(result, str) and isinstance(result, Sequence):
+                        values = []
+                        for item in result:
+                            value = DataLocator._locate_path_parts(
+                                item,
+                                remaining,
+                                style=style,
+                                default=default,
+                            )
+                            if value is default:
+                                return default
+                            values.append(value)
+                        return values
+                    return default
+                try:
+                    index = int(path_index)
+                except Exception:
+                    return default
+                if not isinstance(result, str) and isinstance(result, Sequence):
+                    try:
+                        return DataLocator._locate_path_parts(
+                            result[index],
+                            remaining,
+                            style=style,
+                            default=default,
+                        )
+                    except Exception:
+                        return default
+                return default
+            else:
+                if isinstance(result, Mapping):
+                    return DataLocator._locate_path_parts(
+                        result.get(path_part, default),
+                        remaining,
+                        style=style,
+                        default=default,
+                    )
+                return default
+        else:
+            if path_part == "*":
+                if not isinstance(result, str) and isinstance(result, Sequence):
+                    values = []
+                    for item in result:
+                        value = DataLocator._locate_path_parts(
+                            item,
+                            remaining,
+                            style=style,
+                            default=default,
+                        )
+                        if value is default:
+                            return default
+                        values.append(value)
+                    return values
+                return default
+            if isinstance(result, Mapping):
+                return DataLocator._locate_path_parts(
+                    result.get(path_part, default),
+                    remaining,
+                    style=style,
+                    default=default,
+                )
+            if not isinstance(result, str) and isinstance(result, Sequence):
+                try:
+                    return DataLocator._locate_path_parts(
+                        result[int(path_part)],
+                        remaining,
+                        style=style,
+                        default=default,
+                    )
+                except Exception:
+                    return default
+            return default
+
     @staticmethod
     def locate_path_in_dict(
         original_dict: dict,
@@ -34,42 +129,24 @@ class DataLocator:
         match style:
             case "dot":
                 try:
-                    result = original_dict
                     path_parts = path.split(".")
-                    for path_part in path_parts:
-                        if "[" in path_part:
-                            path_key_and_index = path_part.split("[")
-                            path_key = path_key_and_index[0]
-                            path_index = int(path_key_and_index[1][:-1])
-                            if isinstance(result, Mapping):
-                                result = result[path_key]
-                            else:
-                                return default
-                            if not isinstance(result, str) and isinstance(result, Sequence):
-                                result = result[path_index]
-                            else:
-                                return default
-                        else:
-                            if isinstance(result, Mapping):
-                                result = result[path_part]
-                            else:
-                                return default
-                    return result
+                    return DataLocator._locate_path_parts(
+                        original_dict,
+                        path_parts,
+                        style="dot",
+                        default=default,
+                    )
                 except Exception:
                     return default
             case "slash":
-                result = original_dict
-                path_parts = path.split("/")
                 try:
-                    for path_part in path_parts:
-                        if path_part:
-                            if isinstance(result, Mapping):
-                                result = result[path_part]
-                            elif not isinstance(result, str) and isinstance(result, Sequence):
-                                result = result[int(path_part)]
-                            else:
-                                return default
-                    return result
+                    path_parts = [part for part in path.split("/") if part]
+                    return DataLocator._locate_path_parts(
+                        original_dict,
+                        path_parts,
+                        style="slash",
+                        default=default,
+                    )
                 except Exception:
                     return default
 

{agently-4.0.6.11 → agently-4.0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agently"
-version = "4.0.6.11"
+version = "4.0.7.1"
 description = ""
 authors = [
     {name = "Agently Team",email = "developer@agently.tech"},