zrb 1.21.31__py3-none-any.whl → 1.21.43__py3-none-any.whl

zrb/task/base_task.py

@@ -3,7 +3,7 @@ import inspect
 from collections.abc import Callable
 from typing import Any
 
-from zrb.attr.type import BoolAttr, fstring
+from zrb.attr.type import fstring
 from zrb.context.any_context import AnyContext
 from zrb.env.any_env import AnyEnv
 from zrb.input.any_input import AnyInput
@@ -55,7 +55,7 @@ class BaseTask(AnyTask):
         input: list[AnyInput | None] | AnyInput | None = None,
         env: list[AnyEnv | None] | AnyEnv | None = None,
         action: fstring | Callable[[AnyContext], Any] | None = None,
-        execute_condition: BoolAttr = True,
+        execute_condition: bool | str | Callable[[AnyContext], bool] = True,
         retries: int = 2,
         retry_period: float = 0,
         readiness_check: list[AnyTask] | AnyTask | None = None,
@@ -68,9 +68,18 @@ class BaseTask(AnyTask):
         fallback: list[AnyTask] | AnyTask | None = None,
         successor: list[AnyTask] | AnyTask | None = None,
     ):
-        caller_frame = inspect.stack()[1]
-        self.__decl_file = caller_frame.filename
-        self.__decl_line = caller_frame.lineno
+        # Optimized stack retrieval
+        frame = inspect.currentframe()
+        if frame is not None:
+            caller_frame = frame.f_back
+            self.__decl_file = (
+                caller_frame.f_code.co_filename if caller_frame else "unknown"
+            )
+            self.__decl_line = caller_frame.f_lineno if caller_frame else 0
+        else:
+            self.__decl_file = "unknown"
+            self.__decl_line = 0
+
         self._name = name
         self._color = color
         self._icon = icon
@@ -80,10 +89,10 @@ class BaseTask(AnyTask):
         self._envs = env
         self._retries = retries
         self._retry_period = retry_period
-        self._upstreams = upstream
-        self._fallbacks = fallback
-        self._successors = successor
-        self._readiness_checks = readiness_check
+        self._upstreams = self._ensure_task_list(upstream)
+        self._fallbacks = self._ensure_task_list(fallback)
+        self._successors = self._ensure_task_list(successor)
+        self._readiness_checks = self._ensure_task_list(readiness_check)
         self._readiness_check_delay = readiness_check_delay
         self._readiness_check_period = readiness_check_period
         self._readiness_failure_threshold = readiness_failure_threshold
@@ -92,6 +101,13 @@ class BaseTask(AnyTask):
         self._execute_condition = execute_condition
         self._action = action
 
+    def _ensure_task_list(self, tasks: AnyTask | list[AnyTask] | None) -> list[AnyTask]:
+        if tasks is None:
+            return []
+        if isinstance(tasks, list):
+            return tasks
+        return [tasks]
+
     def __repr__(self):
         return f"<{self.__class__.__name__} name={self.name}>"
 
@@ -132,18 +148,10 @@ class BaseTask(AnyTask):
     @property
     def fallbacks(self) -> list[AnyTask]:
         """Returns the list of fallback tasks."""
-        if self._fallbacks is None:
-            return []
-        elif isinstance(self._fallbacks, list):
-            return self._fallbacks
-        return [self._fallbacks]  # Assume single task
+        return self._fallbacks
 
     def append_fallback(self, fallbacks: AnyTask | list[AnyTask]):
         """Appends fallback tasks, ensuring no duplicates."""
-        if self._fallbacks is None:
-            self._fallbacks = []
-        elif not isinstance(self._fallbacks, list):
-            self._fallbacks = [self._fallbacks]
         to_add = fallbacks if isinstance(fallbacks, list) else [fallbacks]
         for fb in to_add:
             if fb not in self._fallbacks:
@@ -152,18 +160,10 @@ class BaseTask(AnyTask):
     @property
     def successors(self) -> list[AnyTask]:
         """Returns the list of successor tasks."""
-        if self._successors is None:
-            return []
-        elif isinstance(self._successors, list):
-            return self._successors
-        return [self._successors]  # Assume single task
+        return self._successors
 
     def append_successor(self, successors: AnyTask | list[AnyTask]):
         """Appends successor tasks, ensuring no duplicates."""
-        if self._successors is None:
-            self._successors = []
-        elif not isinstance(self._successors, list):
-            self._successors = [self._successors]
         to_add = successors if isinstance(successors, list) else [successors]
         for succ in to_add:
             if succ not in self._successors:
@@ -172,18 +172,10 @@ class BaseTask(AnyTask):
     @property
     def readiness_checks(self) -> list[AnyTask]:
         """Returns the list of readiness check tasks."""
-        if self._readiness_checks is None:
-            return []
-        elif isinstance(self._readiness_checks, list):
-            return self._readiness_checks
-        return [self._readiness_checks]  # Assume single task
+        return self._readiness_checks
 
     def append_readiness_check(self, readiness_checks: AnyTask | list[AnyTask]):
         """Appends readiness check tasks, ensuring no duplicates."""
-        if self._readiness_checks is None:
-            self._readiness_checks = []
-        elif not isinstance(self._readiness_checks, list):
-            self._readiness_checks = [self._readiness_checks]
         to_add = (
             readiness_checks
             if isinstance(readiness_checks, list)
@@ -196,18 +188,10 @@ class BaseTask(AnyTask):
     @property
     def upstreams(self) -> list[AnyTask]:
         """Returns the list of upstream tasks."""
-        if self._upstreams is None:
-            return []
-        elif isinstance(self._upstreams, list):
-            return self._upstreams
-        return [self._upstreams]  # Assume single task
+        return self._upstreams
 
     def append_upstream(self, upstreams: AnyTask | list[AnyTask]):
         """Appends upstream tasks, ensuring no duplicates."""
-        if self._upstreams is None:
-            self._upstreams = []
-        elif not isinstance(self._upstreams, list):
-            self._upstreams = [self._upstreams]
         to_add = upstreams if isinstance(upstreams, list) else [upstreams]
         for up in to_add:
             if up not in self._upstreams:
@@ -277,6 +261,8 @@ class BaseTask(AnyTask):
         try:
             # Delegate to the helper function for the default behavior
             return await run_default_action(self, ctx)
+        except (KeyboardInterrupt, GeneratorExit):
+            raise
         except BaseException as e:
             additional_error_note = (
                 f"Task: {self.name} ({self.__decl_file}:{self.__decl_line})"

zrb/task/base_trigger.py

@@ -5,7 +5,6 @@ from typing import Any
 from zrb.attr.type import fstring
 from zrb.callback.any_callback import AnyCallback
 from zrb.context.any_context import AnyContext
-from zrb.context.any_shared_context import AnySharedContext
 from zrb.context.shared_context import SharedContext
 from zrb.dot_dict.dot_dict import DotDict
 from zrb.env.any_env import AnyEnv

zrb/task/cmd_task.py

@@ -48,6 +48,7 @@ class CmdTask(BaseTask):
         warn_unrecommended_command: bool | None = None,
         max_output_line: int = 1000,
         max_error_line: int = 1000,
+        execution_timeout: int = 3600,
         is_interactive: bool = False,
         execute_condition: BoolAttr = True,
         retries: int = 2,
@@ -103,6 +104,7 @@ class CmdTask(BaseTask):
         self._render_cwd = render_cwd
         self._max_output_line = max_output_line
         self._max_error_line = max_error_line
+        self._execution_timeout = execution_timeout
         self._should_plain_print = plain_print
         self._should_warn_unrecommended_command = warn_unrecommended_command
         self._is_interactive = is_interactive
@@ -142,6 +144,7 @@ class CmdTask(BaseTask):
             register_pid_method=lambda pid: ctx.xcom.get(xcom_pid_key).push(pid),
             max_output_line=self._max_output_line,
             max_error_line=self._max_error_line,
+            timeout=self._execution_timeout,
             is_interactive=self._is_interactive,
         )
         # Check for errors

zrb/task/llm/agent.py

@@ -39,39 +39,10 @@ def create_agent_instance(
     auto_summarize: bool = True,
 ) -> "Agent[None, Any]":
     """Creates a new Agent instance with configured tools and servers."""
-    from pydantic_ai import Agent, RunContext, Tool
+    from pydantic_ai import Agent, Tool
     from pydantic_ai.tools import GenerateToolJsonSchema
-    from pydantic_ai.toolsets import ToolsetTool, WrapperToolset
 
-    @dataclass
-    class ConfirmationWrapperToolset(WrapperToolset):
-        ctx: AnyContext
-        yolo_mode: bool | list[str]
-
-        async def call_tool(
-            self, name: str, tool_args: dict, ctx: RunContext, tool: ToolsetTool[None]
-        ) -> Any:
-            # The `tool` object is passed in. Use it for inspection.
-            # Define a temporary function that performs the actual tool call.
-            async def execute_delegated_tool_call(**params):
-                # Pass all arguments down the chain.
-                return await self.wrapped.call_tool(name, tool_args, ctx, tool)
-
-            # For the confirmation UI, make our temporary function look like the real one.
-            try:
-                execute_delegated_tool_call.__name__ = name
-                execute_delegated_tool_call.__doc__ = tool.function.__doc__
-                execute_delegated_tool_call.__signature__ = inspect.signature(
-                    tool.function
-                )
-            except (AttributeError, TypeError):
-                pass  # Ignore if we can't inspect the original function
-            # Use the existing wrap_func to get the confirmation logic
-            wrapped_executor = wrap_func(
-                execute_delegated_tool_call, self.ctx, self.yolo_mode
-            )
-            # Call the wrapped executor. This will trigger the confirmation prompt.
-            return await wrapped_executor(**tool_args)
+    ConfirmationWrapperToolset = _get_confirmation_wrapper_toolset_class()
 
     if yolo_mode is None:
         yolo_mode = False
@@ -132,6 +103,43 @@ def create_agent_instance(
     )
 
 
+def _get_confirmation_wrapper_toolset_class():
+    from pydantic_ai import RunContext
+    from pydantic_ai.toolsets import ToolsetTool, WrapperToolset
+
+    @dataclass
+    class ConfirmationWrapperToolset(WrapperToolset):
+        ctx: AnyContext
+        yolo_mode: bool | list[str]
+
+        async def call_tool(
+            self, name: str, tool_args: dict, ctx: RunContext, tool: ToolsetTool[None]
+        ) -> Any:
+            # The `tool` object is passed in. Use it for inspection.
+            # Define a temporary function that performs the actual tool call.
+            async def execute_delegated_tool_call(**params):
+                # Pass all arguments down the chain.
+                return await self.wrapped.call_tool(name, tool_args, ctx, tool)
+
+            # For the confirmation UI, make our temporary function look like the real one.
+            try:
+                execute_delegated_tool_call.__name__ = name
+                execute_delegated_tool_call.__doc__ = tool.function.__doc__
+                execute_delegated_tool_call.__signature__ = inspect.signature(
+                    tool.function
+                )
+            except (AttributeError, TypeError):
+                pass  # Ignore if we can't inspect the original function
+            # Use the existing wrap_func to get the confirmation logic
+            wrapped_executor = wrap_func(
+                execute_delegated_tool_call, self.ctx, self.yolo_mode
+            )
+            # Call the wrapped executor. This will trigger the confirmation prompt.
+            return await wrapped_executor(**tool_args)
+
+    return ConfirmationWrapperToolset
+
+
 def get_agent(
     ctx: AnyContext,
     model: "str | Model",

zrb/task/llm/agent_runner.py

@@ -1,4 +1,9 @@
+import asyncio
 import json
+import os
+import sys
+import termios
+import tty
 from collections.abc import Callable
 from typing import TYPE_CHECKING, Any
 
@@ -93,11 +98,17 @@ async def _run_single_agent_iteration(
             message_history=ModelMessagesTypeAdapter.validate_python(history_list),
             usage_limits=UsageLimits(request_limit=None),  # We don't want limit
         ) as agent_run:
+            escape_task = asyncio.create_task(_wait_for_escape(ctx))
             async for node in agent_run:
                 # Each node represents a step in the agent's execution
                 try:
                     await print_node(
-                        _get_plain_printer(ctx), agent_run, node, log_indent_level
+                        _get_plain_printer(ctx),
+                        agent_run,
+                        node,
+                        ctx.is_tty,
+                        log_indent_level,
+                        lambda: escape_task.done(),
                     )
                 except APIError as e:
                     # Extract detailed error information from the response
@@ -108,12 +119,63 @@ async def _run_single_agent_iteration(
                     ctx.log_error(f"Error processing node: {str(e)}")
                     ctx.log_error(f"Error type: {type(e).__name__}")
                     raise
+                if escape_task.done():
+                    break
+            # Clean escape_task
+            if not escape_task.done():
+                try:
+                    escape_task.cancel()
+                    await escape_task
+                except asyncio.CancelledError:
+                    pass
             return agent_run
 
 
+async def _wait_for_escape(ctx: AnyContext) -> None:
+    if not ctx.is_tty:
+        # Wait forever
+        await asyncio.Future()
+        return
+    loop = asyncio.get_event_loop()
+    future = loop.create_future()
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    try:
+        tty.setcbreak(fd)
+        loop.add_reader(fd, _create_escape_detector(ctx, future, fd))
+        await future
+    except asyncio.CancelledError:
+        raise
+    finally:
+        loop.remove_reader(fd)
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
+
+
+def _create_escape_detector(
+    ctx: AnyContext, future: asyncio.Future[Any], fd: int | Any
+) -> Callable[[], None]:
+    def on_stdin():
+        try:
+            # Read just one byte
+            ch = os.read(fd, 1)
+            if ch == b"\x1b":
+                ctx.print("\n🚫 Interrupted by user.", plain=True)
+                if not future.done():
+                    future.set_result(None)
+        except Exception as e:
+            if not future.done():
+                future.set_exception(e)
+
+    return on_stdin
+
+
 def _create_print_throttle_notif(ctx: AnyContext) -> Callable[[str], None]:
-    def _print_throttle_notif(reason: str):
-        ctx.print(stylize_faint(f"  ⌛>> Request Throttled: {reason}"), plain=True)
+    def _print_throttle_notif(text: str, *args: Any, **kwargs: Any):
+        new_line = kwargs.get("new_line", True)
+        prefix = "\r" if not new_line else "\n"
+        if text != "":
+            prefix = f"{prefix}  🐢 Request Throttled: "
+        ctx.print(stylize_faint(f"{prefix}{text}"), plain=True, end="")
 
     return _print_throttle_notif
 

zrb/task/llm/default_workflow/researching/workflow.md

@@ -9,6 +9,7 @@ Follow this workflow to deliver accurate, well-sourced, and synthesized research
 - **Source Hierarchy:** Prioritize authoritative sources over secondary ones
 - **Synthesis Excellence:** Connect information into coherent narratives
 - **Comprehensive Attribution:** Cite all significant claims and data points
+- **Mandatory Citations:** ALWAYS include a "Sources" section at the end of the response with a list of all URLs used.
 
 # Tool Usage Guideline
 - Use `search_internet` for web research and information gathering
@@ -114,6 +115,7 @@ Follow this workflow to deliver accurate, well-sourced, and synthesized research
 - **Detailed Analysis:** Provide comprehensive information for deep dives
 - **Actionable Insights:** Highlight implications and recommended actions
 - **Further Reading:** Suggest additional resources for interested readers
+- **Sources:** ALWAYS end the response with a "Sources" section listing all URLs used.
 
 # Risk Assessment Guidelines
 

zrb/task/llm/history_list.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+
+def remove_system_prompt_and_instruction(
+    history_list: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    for msg in history_list:
+        if msg.get("instructions"):
+            msg["instructions"] = ""
+        msg["parts"] = [
+            p for p in msg.get("parts", []) if p.get("part_kind") != "system-prompt"
+        ]
+    return history_list

zrb/task/llm/history_processor.py

@@ -88,30 +88,21 @@ def create_summarize_history_processor(
         messages: list[ModelMessage],
     ) -> list[ModelMessage]:
         history_list = json.loads(ModelMessagesTypeAdapter.dump_json(messages))
-        history_json_str = json.dumps(history_list)
+        history_list_str = json.dumps(history_list)
         # Estimate token usage
         # Note: Pydantic ai has run context parameter
         # (https://ai.pydantic.dev/message-history/#runcontext-parameter)
         # But we cannot use run_ctx.usage.total_tokens because total token keep increasing
         # even after summariztion.
-        estimated_token_usage = rate_limitter.count_token(history_json_str)
+        estimated_token_usage = rate_limitter.count_token(history_list_str)
         _print_request_info(
             ctx, estimated_token_usage, summarization_token_threshold, messages
         )
         if estimated_token_usage < summarization_token_threshold or len(messages) == 1:
             return messages
-        history_list_without_instruction = [
-            {
-                key: obj[key]
-                for key in obj
-                if index == len(history_list) - 1 or key != "instructions"
-            }
-            for index, obj in enumerate(history_list)
-        ]
-        history_json_str_without_instruction = json.dumps(
-            history_list_without_instruction
+        summarization_message = (
+            f"Summarize the following conversation: {history_list_str}"
         )
-        summarization_message = f"Summarize the following conversation: {history_json_str_without_instruction}"
         summarization_agent = Agent[None, ConversationSummary](
             model=summarization_model,
             output_type=save_conversation_summary,

zrb/task/llm/print_node.py

@@ -1,3 +1,4 @@
+import asyncio
 import json
 from collections.abc import Callable
 from typing import Any
@@ -7,7 +8,12 @@ from zrb.util.cli.style import stylize_faint
 
 
 async def print_node(
-    print_func: Callable, agent_run: Any, node: Any, log_indent_level: int = 0
+    print_func: Callable,
+    agent_run: Any,
+    node: Any,
+    is_tty: bool,
+    log_indent_level: int = 0,
+    stop_check: Callable[[], bool] | None = None,
 ):
     """Prints the details of an agent execution node using a provided print function."""
     from pydantic_ai import Agent
@@ -24,45 +30,83 @@ async def print_node(
     )
 
     meta = getattr(node, "id", None) or getattr(node, "request_id", None)
+    progress_char_list = ["|", "/", "-", "\\"]
+    progress_index = 0
     if Agent.is_user_prompt_node(node):
         print_func(_format_header("🔠 Receiving input...", log_indent_level))
-    elif Agent.is_model_request_node(node):
+        return
+    if Agent.is_model_request_node(node):
         # A model request node => We can stream tokens from the model's request
-        print_func(_format_header("🧠 Processing...", log_indent_level))
+        esc_notif = " (Press esc to cancel)" if is_tty else ""
+        print_func(_format_header(f"🧠 Processing{esc_notif}...", log_indent_level))
         # Reference: https://ai.pydantic.dev/agents/#streaming-all-events-and-output
         try:
             async with node.stream(agent_run.ctx) as request_stream:
                 is_streaming = False
+                is_tool_processing = False
                 async for event in request_stream:
+                    if stop_check and stop_check():
+                        return
+                    await asyncio.sleep(0)
                     if isinstance(event, PartStartEvent) and event.part:
                         if is_streaming:
                             print_func("")
                         content = _get_event_part_content(event)
                         print_func(_format_content(content, log_indent_level), end="")
                         is_streaming = True
-                    elif isinstance(event, PartDeltaEvent):
+                        is_tool_processing = False
+                        continue
+                    if isinstance(event, PartDeltaEvent):
                         if isinstance(event.delta, TextPartDelta):
                             content_delta = event.delta.content_delta
                             print_func(
                                 _format_stream_content(content_delta, log_indent_level),
                                 end="",
                             )
-                        elif isinstance(event.delta, ThinkingPartDelta):
+                            is_tool_processing = False
+                            is_streaming = True
+                            continue
+                        if isinstance(event.delta, ThinkingPartDelta):
                             content_delta = event.delta.content_delta
                             print_func(
                                 _format_stream_content(content_delta, log_indent_level),
                                 end="",
                             )
-                        elif isinstance(event.delta, ToolCallPartDelta):
-                            args_delta = event.delta.args_delta
-                            if isinstance(args_delta, dict):
-                                args_delta = json.dumps(args_delta)
+                            is_tool_processing = False
+                            is_streaming = True
+                            continue
+                        if isinstance(event.delta, ToolCallPartDelta):
+                            if CFG.LLM_SHOW_TOOL_CALL_PREPARATION:
+                                args_delta = event.delta.args_delta
+                                if isinstance(args_delta, dict):
+                                    args_delta = json.dumps(args_delta)
+                                print_func(
+                                    _format_stream_content(
+                                        args_delta, log_indent_level
+                                    ),
+                                    end="",
+                                )
+                                is_streaming = True
+                                is_tool_processing = True
+                                continue
+                            prefix = "\n" if not is_tool_processing else ""
+                            progress_char = progress_char_list[progress_index]
                             print_func(
-                                _format_stream_content(args_delta, log_indent_level),
+                                _format_content(
+                                    f"Preparing Tool Parameters... {progress_char}",
+                                    log_indent_level,
+                                    prefix=f"\r{prefix}",
+                                ),
                                 end="",
                             )
+                            progress_index += 1
+                            if progress_index >= len(progress_char_list):
+                                progress_index = 0
+                            is_tool_processing = True
+                            is_streaming = True
+                            continue
                         is_streaming = True
-                    elif isinstance(event, FinalResultEvent) and event.tool_name:
+                    if isinstance(event, FinalResultEvent) and event.tool_name:
                         if is_streaming:
                             print_func("")
                         tool_name = event.tool_name
@@ -72,6 +116,7 @@ async def print_node(
                             )
                         )
                         is_streaming = False
+                        is_tool_processing = False
                 if is_streaming:
                     print_func("")
         except UnexpectedModelBehavior as e:
@@ -85,12 +130,16 @@ async def print_node(
                     log_indent_level,
                 )
             )
-    elif Agent.is_call_tools_node(node):
+        return
+    if Agent.is_call_tools_node(node):
         # A handle-response node => The model returned some data, potentially calls a tool
         print_func(_format_header("🧰 Calling Tool...", log_indent_level))
         try:
             async with node.stream(agent_run.ctx) as handle_stream:
                 async for event in handle_stream:
+                    if stop_check and stop_check():
+                        return
+                    await asyncio.sleep(0)
                     if isinstance(event, FunctionToolCallEvent):
                         args = _get_event_part_args(event)
                         call_id = event.part.tool_call_id
@@ -100,7 +149,8 @@ async def print_node(
                                 f"{call_id} | Call {tool_name} {args}", log_indent_level
                             )
                         )
-                    elif (
+                        continue
+                    if (
                         isinstance(event, FunctionToolResultEvent)
                         and event.tool_call_id
                     ):
@@ -113,12 +163,10 @@ async def print_node(
                                     log_indent_level,
                                 )
                             )
-                        else:
-                            print_func(
-                                _format_content(
-                                    f"{call_id} | Executed", log_indent_level
-                                )
-                            )
+                            continue
+                        print_func(
+                            _format_content(f"{call_id} | Executed", log_indent_level)
+                        )
         except UnexpectedModelBehavior as e:
             print_func("")  # ensure newline consistency
             print_func(
@@ -130,9 +178,11 @@ async def print_node(
                     log_indent_level,
                 )
             )
-    elif Agent.is_end_node(node):
+        return
+    if Agent.is_end_node(node):
         # Once an End node is reached, the agent run is complete
         print_func(_format_header("✅ Completed...", log_indent_level))
+        return
 
 
 def _format_header(text: str | None, log_indent_level: int = 0) -> str:
@@ -145,8 +195,10 @@ def _format_header(text: str | None, log_indent_level: int = 0) -> str:
     )
 
 
-def _format_content(text: str | None, log_indent_level: int = 0) -> str:
-    return _format(
+def _format_content(
+    text: str | None, log_indent_level: int = 0, prefix: str = ""
+) -> str:
+    return prefix + _format(
         text,
         base_indent=2,
         first_indent=3,
@@ -155,8 +207,10 @@ def _format_content(text: str | None, log_indent_level: int = 0) -> str:
     )
 
 
-def _format_stream_content(text: str | None, log_indent_level: int = 0) -> str:
-    return _format(
+def _format_stream_content(
+    text: str | None, log_indent_level: int = 0, prefix: str = ""
+) -> str:
+    return prefix + _format(
         text,
         base_indent=2,
         indent=3,
@@ -207,7 +261,7 @@ def _truncate_kwargs(kwargs: dict[str, Any]) -> dict[str, Any]:
     return {key: _truncate_arg(val) for key, val in kwargs.items()}
 
 
-def _truncate_arg(arg: str, length: int = 19) -> str:
+def _truncate_arg(arg: str, length: int = 30) -> str:
     if isinstance(arg, str) and len(arg) > length:
         return f"{arg[:length-4]} ..."
     return arg