agently 4.0.7__tar.gz → 4.0.7.1__tar.gz

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

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

{agently-4.0.7 → 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.7 → 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.7 → 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.7 → 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.7 → 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,
@@ -467,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.7 → agently-4.0.7.1}/agently/core/TriggerFlow/TriggerFlow.py

@@ -227,7 +227,7 @@ class TriggerFlow:
         self,
         initial_value: Any = None,
         *,
-        timeout: int | None = 10,
+        timeout: float | None = 10.0,
         concurrency: int | None = None,
     ):
         execution = self.create_execution(concurrency=concurrency)

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

@@ -294,16 +294,20 @@ 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 = chunk.async_call
+                handler = typed_chunk.async_call
             else:
-                async def handler(data: "TriggerFlowEventData", _chunk=chunk):
-                    async with semaphore:
-                        return await _chunk.async_call(data)
+                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,

{agently-4.0.7 → 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.7 → 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.7 → agently-4.0.7.1}/pyproject.toml

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