waldiez 0.5.9__py3-none-any.whl → 0.6.0__py3-none-any.whl

waldiez/io/models/user_input.py

@@ -97,7 +97,7 @@ class UserInputData(BaseModel):
                 parsed = json.loads(parsed)
             except json.JSONDecodeError:
                 return TextMediaContent(type="text", text=parsed)
-            if isinstance(parsed, str):
+            if isinstance(parsed, str):  # pragma: no cover
                 return TextMediaContent(type="text", text=parsed)
         return cls.validate_content(parsed)
 
@@ -256,15 +256,15 @@ def extract_filename_from_path(path_or_url: str) -> str:
         filename = os.path.basename(parsed.path)
 
         # Handle edge cases where path might be empty or end with /
-        if not filename and parsed.path.endswith("/"):
+        if not filename and parsed.path.endswith("/"):  # pragma: no cover
             # Try to get the last directory name
             path_parts = [p for p in parsed.path.split("/") if p]
             filename = path_parts[-1] if path_parts else parsed.netloc
-        elif not filename:
+        elif not filename:  # pragma: no cover
             # Fallback to using netloc (domain) if no path
             filename = parsed.netloc
 
         return filename
     # else:
     # Local file path
-    return os.path.basename(path_or_url)
+    return os.path.basename(path_or_url)  # pragma: no cover

waldiez/io/models/user_response.py

@@ -209,6 +209,7 @@ class UserResponse(StructuredBase):
         # we have probably returned sth till here
         if isinstance(self.data, str):  # pyright: ignore # pragma: no cover
             return self.data
+        # noinspection PyUnreachableCode
         return (  # pragma: no cover
             json.dumps(self.data)
             if hasattr(self.data, "__dict__")

waldiez/io/mqtt.py

@@ -473,7 +473,7 @@ class MqttIOStream(IOStream):
         print_message = PrintMessage.create(*args, **kwargs)
         try:
             payload = print_message.model_dump(mode="json")
-        except Exception:
+        except Exception:  # pragma: no cover
             payload = print_message.model_dump(
                 serialize_as_any=True, mode="json", fallback=str
             )

waldiez/io/structured.py

@@ -10,7 +10,6 @@ import threading
 from getpass import getpass
 from pathlib import Path
 from typing import Any
-from uuid import uuid4
 
 from autogen.events import BaseEvent  # type: ignore
 from autogen.io import IOStream  # type: ignore
@@ -23,6 +22,9 @@ from .models import (
     UserResponse,
 )
 from .utils import (
+    DEBUG_INPUT_PROMPT,
+    START_CHAT_PROMPT,
+    MessageType,
     gen_id,
     get_image,
     get_message_dump,
@@ -63,29 +65,43 @@ class StructuredIOStream(IOStream):
         """
         sep = kwargs.get("sep", " ")
         end = kwargs.get("end", "\n")
+        flush = kwargs.get("flush", True)
+        payload_type = kwargs.get("type", "print")
         message = sep.join(map(str, args))
-        is_dumped = is_json_dumped(message)
-        if is_dumped and end.endswith("\n"):
+        if len(args) == 1 and isinstance(args[0], dict):
+            message = args[0]  # pyright: ignore
+            payload_type = message.get("type", payload_type)  # pyright: ignore
+            is_dumped = True
+        else:
+            is_dumped, message = is_json_dumped(message)
+        if is_dumped:
             # If the message is already JSON-dumped,
             # let's try not to double dump it
-            message = json.loads(message)
             payload: dict[str, Any] = {
-                "type": "print",
-                "id": uuid4().hex,
+                "id": gen_id(),
                 "timestamp": now(),
-                "data": message,
+                # "data": message,
             }
+            if isinstance(message, dict):
+                payload.update(message)  # pyright: ignore
+            else:
+                payload["data"] = message
+            if "type" not in payload:
+                payload["type"] = payload_type
         else:
-            message += end
-            payload = PrintMessage(
-                id=uuid4().hex,
-                timestamp=now(),
-                data=message,
-            ).model_dump(mode="json")
-        flush = kwargs.get("flush", True)
-        payload_type = kwargs.get("type", "print")
-        payload["type"] = payload_type
-        print(json.dumps(payload, default=str), flush=flush)
+            print_message = PrintMessage(data=message)  # pyright: ignore
+            payload = print_message.model_dump(mode="json", fallback=str)
+            payload["type"] = payload_type
+        dumped = json.dumps(payload, default=str, ensure_ascii=False) + end
+        if kwargs.get("file") and kwargs["file"] in [
+            sys.stderr,
+            sys.__stderr__,
+            sys.stdout,
+            sys.__stdout__,
+        ]:
+            print(dumped, file=kwargs["file"], flush=flush)
+        else:
+            print(dumped, flush=flush)
 
     def input(self, prompt: str = "", *, password: bool = False) -> str:
         """Structured input from stdin.
@@ -102,36 +118,27 @@ class StructuredIOStream(IOStream):
         str
             The line read from the input stream.
         """
-        request_id = uuid4().hex
+        request_id = gen_id()
         prompt = prompt or ">"
-        if not prompt or prompt in [">", "> "]:
+        if not prompt or prompt in [">", "> "]:  # pragma: no cover
             # if the prompt is just ">" or "> ",
             # let's use a more descriptive one
-            prompt = "Enter your message to start the conversation: "
-
-        self._send_input_request(prompt, request_id, password)
+            prompt = START_CHAT_PROMPT
+        input_type = "chat"
+        if prompt.strip() == DEBUG_INPUT_PROMPT.strip():
+            input_type = "debug"
+        self._send_input_request(
+            prompt,
+            request_id,
+            password,
+            input_type=input_type,
+        )
         user_input_raw = self._read_user_input(prompt, password, request_id)
         response = self._handle_user_input(user_input_raw, request_id)
         user_response = response.to_string(
             uploads_root=self.uploads_root,
             base_name=request_id,
         )
-        # let's keep an eye here:
-        # https://github.com/ag2ai/ag2/blob/main/autogen/agentchat/conversable_agent.py#L2973
-        # reply = await iostream.input(prompt) ???? (await???)
-        if self.is_async:
-            # let's make a coroutine to just return the user response
-            async def async_input() -> str:
-                """Asynchronous input method.
-
-                Returns
-                -------
-                str
-                    The line read from the input stream.
-                """
-                return user_response
-
-            return async_input()  # type: ignore
         return user_response
 
     # noinspection PyMethodMayBeStatic
@@ -168,14 +175,21 @@ class StructuredIOStream(IOStream):
         self,
         prompt: str,
         request_id: str,
-        password: bool,
+        password: bool = False,
+        input_type: str = "chat",
     ) -> None:
+        if input_type not in ("chat", "debug"):
+            input_type = "chat"
+        request_type = (
+            "debug_input_request" if input_type == "debug" else "input_request"
+        )
         payload = UserInputRequest(
+            type=request_type,  # type: ignore
             request_id=request_id,
             prompt=prompt,
             password=password,
         ).model_dump(mode="json")
-        print(json.dumps(payload), flush=True)
+        print(json.dumps(payload, default=str), flush=True)
 
     def _read_user_input(
         self,
@@ -205,6 +219,11 @@ class StructuredIOStream(IOStream):
         except queue.Empty:
             self._send_timeout_message(request_id)
             return ""
+        except BaseException as e:
+            self._send_error_message(request_id, str(e))
+            return ""
+        finally:
+            input_thread.join(timeout=1)
 
     def _send_timeout_message(self, request_id: str) -> None:
         timeout_payload = {
@@ -216,6 +235,17 @@ class StructuredIOStream(IOStream):
         }
         print(json.dumps(timeout_payload), flush=True, file=sys.stderr)
 
+    # noinspection PyMethodMayBeStatic
+    def _send_error_message(self, request_id: str, error_message: str) -> None:
+        error_payload = {
+            "id": gen_id(),
+            "type": "error",
+            "request_id": request_id,
+            "timestamp": now(),
+            "data": error_message,
+        }
+        print(json.dumps(error_payload), flush=True, file=sys.stderr)
+
     def _handle_user_input(
         self, user_input_raw: str, request_id: str
     ) -> UserResponse:
@@ -294,7 +324,12 @@ class StructuredIOStream(IOStream):
         UserResponse
             The structured user response.
         """
-        # Load the user input
+        response_type: MessageType
+        _response_type = user_input.get("type", "input_response")
+        if _response_type not in ("input_response", "debug_input_response"):
+            response_type = "input_response"
+        else:
+            response_type = _response_type
         if user_input.get("request_id") == request_id:
             # We have a valid response to our request
             data = user_input.get("data")
@@ -302,6 +337,7 @@ class StructuredIOStream(IOStream):
                 # let's check if text|image keys are sent (outside data)
                 if "image" in user_input or "text" in user_input:
                     return UserResponse(
+                        type=response_type,
                         request_id=request_id,
                         data=self._format_multimedia_response(
                             request_id=request_id, data=user_input
@@ -311,10 +347,12 @@ class StructuredIOStream(IOStream):
                 return self._handle_list_response(
                     data,  # pyright: ignore
                     request_id=request_id,
+                    response_type=response_type,
                 )
             if not data or not isinstance(data, (str, dict)):
                 # No / invalid data provided in the response
                 return UserResponse(
+                    type=response_type,
                     request_id=request_id,
                     data="",
                 )
@@ -324,6 +362,7 @@ class StructuredIOStream(IOStream):
                 data = self._load_user_input(data)
             if isinstance(data, dict):
                 return UserResponse(
+                    type=response_type,
                     data=self._format_multimedia_response(
                         request_id=request_id,
                         data=data,  # pyright: ignore
@@ -333,11 +372,14 @@ class StructuredIOStream(IOStream):
             # For other types (numbers, bools ,...),
             #  let's just convert to string
             return UserResponse(
-                data=str(data), request_id=request_id
+                type=response_type,
+                data=str(data),
+                request_id=request_id,
             )  # pragma: no cover
         # This response doesn't match our request_id, log and return empty
         self._log_mismatched_response(request_id, user_input)
         return UserResponse(
+            type=response_type,
             request_id=request_id,
             data="",
         )
@@ -347,10 +389,12 @@ class StructuredIOStream(IOStream):
         self,
         data: list[dict[str, Any]],
         request_id: str,
+        response_type: MessageType,
     ) -> UserResponse:
         if len(data) == 0:  # pyright: ignore
             # Empty list, return empty response
             return UserResponse(
+                type=response_type,
                 request_id=request_id,
                 data="",
             )
@@ -367,10 +411,12 @@ class StructuredIOStream(IOStream):
         if not input_data:  # pragma: no cover
             # No valid data in the list, return empty response
             return UserResponse(
+                type=response_type,
                 request_id=request_id,
                 data="",
             )
         return UserResponse(
+            type=response_type,
             request_id=request_id,
             data=input_data,
         )
@@ -387,9 +433,16 @@ class StructuredIOStream(IOStream):
             The response received
         """
         # Create a log message
+        got_id: str | None = None
+        if isinstance(response, dict):
+            got_id = response.get("request_id")  # pyright: ignore
+        response_str = str(response)  # pyright: ignore
+        message = response_str[:100] + (
+            "..." if len(response_str) > 100 else ""
+        )
         log_payload: dict[str, Any] = {
             "type": "warning",
-            "id": uuid4().hex,
+            "id": gen_id(),
             "timestamp": now(),
             "data": {
                 "message": (
@@ -398,8 +451,8 @@ class StructuredIOStream(IOStream):
                 ),
                 "details": {
                     "expected_id": expected_id,
-                    "received": str(response)[:100]
-                    + ("..." if len(str(response)) > 100 else ""),
+                    "received_id": got_id,
+                    "message": message,
                 },
             },
         }

waldiez/io/utils.py

@@ -14,9 +14,16 @@ from autogen.agentchat.contrib.img_utils import get_pil_image  # type: ignore
 from autogen.events import BaseEvent  # type: ignore
 from autogen.messages import BaseMessage  # type: ignore
 
+DEBUG_INPUT_PROMPT = (
+    "[Step] (c)ontinue, (r)un, (q)uit, (i)nfo, (h)elp, (st)ats: "
+)
+START_CHAT_PROMPT = "Enter your message to start the conversation: "
+
 MessageType = Literal[
     "input_request",
     "input_response",
+    "debug_input_request",
+    "debug_input_response",
     "print",
     "input",
 ]
@@ -131,26 +138,25 @@ def get_image(
     return image_data
 
 
-def is_json_dumped(value: str) -> bool:
-    """Check if a string is JSON-dumped.
+def is_json_dumped(value: Any) -> tuple[bool, Any]:
+    """Check if a value is JSON-dumped.
 
     Parameters
     ----------
-    value : str
-        The string to check.
+    value : Any
+        The value to check.
 
     Returns
     -------
     bool
-        True if the string is JSON-dumped, False otherwise.
+        True if the value is JSON-dumped, False otherwise.
     """
+    to_check = value.strip() if isinstance(value, str) else value
     try:
-        parsed = json.loads(value)
-        # If we can parse it as JSON and it's not a string,
-        # we consider it JSON-dumped
-        return not isinstance(parsed, str)
+        parsed = json.loads(to_check)
+        return True, parsed
     except json.JSONDecodeError:
-        return False
+        return False, value
 
 
 def try_parse_maybe_serialized(value: str) -> Any:
@@ -170,7 +176,7 @@ def try_parse_maybe_serialized(value: str) -> Any:
     """
     for parser in (json.loads, ast.literal_eval):
         # pylint: disable=broad-exception-caught, too-many-try-statements
-        # noinspection PyBroadException
+        # noinspection PyBroadException,TryExceptPass
         try:
             parsed: dict[str, Any] | list[Any] | str = parser(value)
             # Normalize: if it's a single-item list of a string

waldiez/io/ws.py

@@ -29,7 +29,7 @@ from .utils import (
 
 LOG = logging.getLogger(__name__)
 
-if not is_websocket_available():
+if not is_websocket_available():  # pragma: no cover
     raise ImportError(
         "WebSocket support requires "
         "either the 'websockets' or 'starlette' package. "
@@ -72,14 +72,14 @@ class AsyncWebsocketsIOStream(IOStream):
             websocket, "receive_message"
         ):
             self.websocket: WebSocketConnection = websocket
-        else:
+        else:  # pragma: no cover
             self.websocket = create_websocket_adapter(websocket)
 
         self.is_async = is_async
         self.verbose = verbose
         self.receive_timeout = receive_timeout
 
-        if isinstance(uploads_root, str):
+        if isinstance(uploads_root, str):  # pragma: no cover
             uploads_root = Path(uploads_root)
         if uploads_root is not None:
             uploads_root = uploads_root.resolve()
@@ -94,7 +94,7 @@ class AsyncWebsocketsIOStream(IOStream):
             except RuntimeError:
                 pass
 
-            if loop is not None:
+            if loop is not None:  # pragma: no cover
                 # We're in an async context, create a task
                 asyncio.create_task(self.websocket.send_message(json_dump))
             else:
@@ -118,8 +118,8 @@ class AsyncWebsocketsIOStream(IOStream):
         end = kwargs.get("end", "\n")
         msg = sep.join(str(arg) for arg in args)
 
-        is_dumped = is_json_dumped(msg)
-        if is_dumped and end.endswith("\n"):
+        is_dumped, msg = is_json_dumped(msg)
+        if is_dumped:  # pragma: no cover
             msg = json.loads(msg)
         else:
             msg = f"{msg}{end}"
@@ -145,7 +145,7 @@ class AsyncWebsocketsIOStream(IOStream):
         """
         message_dump = get_message_dump(message)
 
-        if message_dump.get("type") == "text":
+        if message_dump.get("type") == "text":  # pragma: no cover
             content_block = message_dump.get("content")
             if (
                 isinstance(content_block, dict)
@@ -186,7 +186,7 @@ class AsyncWebsocketsIOStream(IOStream):
 
         try:
             return asyncio.run(coro)
-        except RuntimeError:
+        except RuntimeError:  # pragma: no cover
             loop = asyncio.get_event_loop()
             future = asyncio.run_coroutine_threadsafe(coro, loop)
             return future.result()
@@ -215,7 +215,7 @@ class AsyncWebsocketsIOStream(IOStream):
         str
             The user input, or empty string if timeout exceeded.
         """
-        if timeout is None:
+        if timeout is None:  # pragma: no branch
             timeout = self.receive_timeout or 120.0
 
         request_id = uuid.uuid4().hex
@@ -239,9 +239,7 @@ class AsyncWebsocketsIOStream(IOStream):
         await self.websocket.send_message(prompt_dump)
         response = await self.websocket.receive_message(timeout=timeout)
 
-        # Handle empty response from timeout
-        if not response:
-            LOG.warning("Input request timed out after %s seconds", timeout)
+        if not response:  # pragma: no cover
             return ""
 
         if self.verbose: